Multithreading eller hvad det nu hedder?

Dette ville være ulogisk at lade processB styre processA, da processB i din beskrivelse ovenfor er \"child\" af processA. Dette bliver yderst GRIMT at programmere. Hvis du istedet lader processA styre processB er det meget mere logisk, da \"the parent can contol its child\".

Du bruger for øvrigt funktionen: _beginthread(..) til at lave en thread.
Der er desuden STOR forskel på en thread og en process i M$ Window$, så pas på ikke og forveksle dem.

~joha~

Ok det kan du nok have ret i. Ideen her er at processA udfører det egentlige arbejde, dette foregår i en uendelig løkke. Når alting virker efter hensigten er processA færdig efter højst 30 min, hvorefter processA starter forfra.
Min tanke var så at processB skal skyde processA ned, efter 35 min, for hvis den har kørt i 35 min, så hænger den. Omvendt hvis processA er færdig på normalvis, skal process B starte forfra.

I øvrigt bør jeg, hvis jeg har forstået dig ret, sige threadA i stedet for processA etc.

Har du ikke et eksempel, eller en henvisning til et eksempel hvor _beginthread(..) bliver brugt ?

Et eksempel, der er koldt og kynisk kopieret fra MSDN :


/* BEGTHRD.C illustrates multiple threads using functions:
*
*      _beginthread            _endthread
*
*
* This program requires the multithreaded library. For example,
* compile with the following command line:
*    CL /MT /D \"_X86_\" BEGTHRD.C
*
* If you are using the Visual C++ development environment, select the
* Multi-Threaded runtime library in the compiler Project Settings
* dialog box.
*
*/

#include <windows.h>
#include <process.h>    /* _beginthread, _endthread */
#include <stddef.h>
#include <stdlib.h>
#include <conio.h>

void Bounce( void *ch );
void CheckKey( void *dummy );

/* GetRandom returns a random integer between min and max. */
#define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))

BOOL repeat = TRUE;    /* Global repeat flag and video variable */
HANDLE hStdOut;        /* Handle for console window */
CONSOLE_SCREEN_BUFFER_INFO csbi;    /* Console information structure */

void main()
{
    CHAR    ch = \'A\';

    hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );

    /* Get display screen\'s text row and column information. */
  GetConsoleScreenBufferInfo( hStdOut, &csbi );

    /* Launch CheckKey thread to check for terminating keystroke. */
    _beginthread( CheckKey, 0, NULL );

    /* Loop until CheckKey terminates program. */
    while( repeat )
    {
        /* On first loops, launch character threads. */
        _beginthread( Bounce, 0, (void *) (ch++)  );

        /* Wait one second between loops. */
        Sleep( 1000L );
    }
}

/* CheckKey - Thread to wait for a keystroke, then clear repeat flag. */
void CheckKey( void *dummy )
{
    _getch();
    repeat = 0;    /* _endthread implied */

}

/* Bounce - Thread to create and and control a colored letter that moves
* around on the screen.
*
* Params: ch - the letter to be moved
*/
void Bounce( void *ch )
{
    /* Generate letter and color attribute from thread argument. */
    char    blankcell = 0x20;
    char    blockcell = (char) ch;
    BOOL    first = TRUE;
  COORD  oldcoord, newcoord;
  DWORD  result;


    /* Seed random number generator and get initial location. */
    srand( _threadid );
    newcoord.X = GetRandom( 0, csbi.dwSize.X - 1 );
    newcoord.Y = GetRandom( 0, csbi.dwSize.Y - 1 );
    while( repeat )
    {
        /* Pause between loops. */
        Sleep( 100L );

        /* Blank out our old position on the screen, and draw new letter. */
        if( first )
            first = FALSE;
        else
        WriteConsoleOutputCharacter( hStdOut, &blankcell, 1, oldcoord, &result );
        WriteConsoleOutputCharacter( hStdOut, &blockcell, 1, newcoord, &result );

        /* Increment the coordinate for next placement of the block. */
        oldcoord.X = newcoord.X;
        oldcoord.Y = newcoord.Y;
        newcoord.X += GetRandom( -1, 1 );
        newcoord.Y += GetRandom( -1, 1 );

        /* Correct placement (and beep) if about to go off the screen. */
        if( newcoord.X < 0 )
            newcoord.X = 1;
        else if( newcoord.X == csbi.dwSize.X )
            newcoord.X = csbi.dwSize.X - 2;
        else if( newcoord.Y < 0 )
            newcoord.Y = 1;
        else if( newcoord.Y == csbi.dwSize.Y )
            newcoord.Y = csbi.dwSize.Y - 2;

        /* If not at a screen border, continue, otherwise beep. */
        else
            continue;
        Beep( ((char) ch - \'A\') * 100, 175 );
    }
    /* _endthread given to terminate */
    _endthread();
}

Ikke helt hvad jeg efterspurgte wisen, men ok.

http://www.linuxdoc.org/HOWTO/C++Programming-HOWTO-22.html

Har i øvrigt også en guide.

www.linuxdoc.org/HOWTO/C++Programming-HOWTO.html