Newsgroup: it.comp.programmare.win32
Titolo: CloseHandle

Tempo fa ho postato riguardo alla funzione Runtime C _enfthread che mi
generava una eccezione sotto Win2000 .
Ho scoperto che l'eccezione deriva dal fatto che tale funzione chiude
l'handle al thread che termina ,mentre io nel mio codice scrivevo
cosi:
 hThread = StartThread() ;
 WaitForSingleObject(hThread,INFINITE) ;
 value = CloseHandle(hThread) ;
E' il CloseHandle che genera l'eccezione in quanto l'handle al thread
non e' piu' valido (perche' chiuso probabilmente dalla funzione
_endthread() ).
La stessa funzione GetLastError mi ritorna il codice di errore per
Handle non valido .
Tuttavia Borland nell'esempio in linea che indica per l'uso dei thread
scrive cosi :
/*      This function acts as the 'main' function for each new thread.
static  void    threadMain(void *arg) */
{
        printf("Thread %2d has an ID of %u\n", (int)arg,
GetCurrentThreadId());
 
        _endthread();
}
int     main(void)
{
        #define NTHREADS        25
        HANDLE  hThreads[NTHREADS];
        int     i;
 
        //      Create NTHREADS inheritable threads that are initially
        //      suspended and that will run starting at threadMain().
        //      at threadMain().
        for     (i = 0; i < NTHREADS; i++)
        {
                SECURITY_ATTRIBUTES     sa = 
                {
                        sizeof(SECURITY_ATTRIBUTES),    // structure
size
                        0,                              // No security
descriptor
                        TRUE,                           // Thread
handle is inheritable
                };
                DWORD   threadId;
                hThreads[i] = (HANDLE)_beginthreadNT(
                                        threadMain,             //
Thread starting address
                                        4096,                   //
Thread stack size
                                        (void *)i,              //
Thread start argument
                                        &sa,                    //
Thread security
                                        CREATE_SUSPENDED,       //
Create in suspended state
                                        &threadId);             //
Thread ID.
                if      (hThreads[i] == INVALID_HANDLE_VALUE)
                {
                        MessageBox(0, "Thread Creation Failed",
"Error", MB_OK);
                        return  1;
                }
                printf("Created thread %2d with an ID of %u\n", i,
threadId);
        }
        printf("\nPress a key to thaw all threads\n\n");
        getch();
 
        //      Resume the suspended threads.
        for     (i = 0; i < NTHREADS; i++)
                ResumeThread(hThreads[i]);
        //      Wait for all threads to finish execution.
        WaitForMultipleObjects(NTHREADS,        // Number of objects
to wait for
                               hThreads,        // The objects to wait
for
                               TRUE,            // Wait for all
objects
                               INFINITE);       // No timeout
// ****************************************************************
//      Close all of the thread handles.  ??????
        for     (i = 0; i < NTHREADS; i++)
                CloseHandle(hThreads[i]);
// ****************************************************************
 
        return  0;
}
Anche Borland qui chiude gli handle al thread e puntualmente si genera
l'eccezione sotto Win 2000 Prof.
Che fa' Borland si contraddice ? E' un bug della funzione _endthread ?
Come faccio a sapere se un handle e' ancora valido prima di usare
CloseHandle ?
grazie

 CloseHandle ?
GetHandleInformation (che dovrebbe fallire se l'handle non e' valido, ma non
l'ho mai provata)
Ma non dovrebbe servirti in questo caso.

Ma non dovrebbe servirti in questo caso.
La provero', grazie .