Terminazione di un processo

La terminazione di un processo ha i risultati seguenti:

• Tutti i thread rimanenti nel processo vengono contrassegnati per essere interrotti.
• Tutte le risorse allocate dal processo vengono liberate.
• Tutti gli oggetti kernel vengono chiusi.
• Il codice del processo viene rimosso dalla memoria.
• Il codice di uscita del processo è impostato.
• L'oggetto processo viene segnalato.

Mentre gli handle aperti per gli oggetti kernel vengono chiusi automaticamente quando termina un processo, gli oggetti stessi esistono fino a quando non vengono chiusi tutti gli handle aperti. Pertanto, un oggetto rimarrà valido dopo che un processo che lo sta utilizzando è terminato, se un altro processo dispone di un handle aperto per esso.

La funzioneGetExitCodeProcessrestituisce lo stato di terminazione di un processo. Durante l'esecuzione di un processo, lo stato di terminazione è STILL_ACTIVE. Quando un processo termina, lo stato di terminazione cambia da STILL_ACTIVE al codice di uscita del processo.

Quando un processo termina, lo stato dell'oggetto processo viene segnalato, rilasciando eventuali thread in attesa del termine del processo. Per altre informazioni sulla sincronizzazione, vedere Sincronizzazione dell'esecuzione di più thread.

Quando il sistema termina un processo, non termina alcun processo figlio creato dal processo. La terminazione di un processo non genera notifiche per WH_CBT procedure hook.

Usare la funzione SetProcessShutdownParameters per specificare alcuni aspetti della terminazione del processo all'arresto del sistema, ad esempio quando un processo deve terminare rispetto agli altri processi nel sistema.

Modalità di terminazione dei processi

Un processo viene eseguito fino a quando non si verifica uno degli eventi seguenti:

• Qualsiasi thread del processo chiama la funzione ExitProcess. Si noti che alcune implementazioni della libreria run-time C (CRT) richiamano ExitProcess se il thread principale del processo termina.
• L'ultimo thread del processo termina.
• Qualsiasi thread chiama la funzione TerminateProcess con un handle per il processo.
• Per i processi della console, il gestore del controllo della console predefinito chiama ExitProcess quando la console riceve un segnale CTRL+C o CTRL+BREAK.
• L'utente arresta il sistema o si disconnette.

Non terminare un processo a meno che i thread non si trovino in stati noti. Se un thread è in attesa su un oggetto kernel, non verrà terminato finché l'attesa non sarà completata. Ciò può causare l'interruzione della risposta dell'applicazione.

Il thread primario può evitare di terminare altri thread indirizzandoli a chiamare ExitThread prima di causare il termine del processo. Per altre informazioni, vedere Terminazione di un thread). Il thread primario può comunque chiamare ExitProcess successivamente per assicurarsi che tutti i thread vengano terminati.

Il codice di uscita per un processo è il valore specificato nella chiamata a ExitProcess o TerminateProcessoppure il valore restituito dalla funzione principale o WinMain del processo. Se un processo viene terminato a causa di un'eccezione irreversibile, il codice di uscita è il valore dell'eccezione che ha causato la terminazione. Questo valore viene inoltre usato come codice di uscita per tutti i thread in esecuzione quando si è verificata l'eccezione.

Se un processo viene terminato da ExitProcess, il sistema chiama la funzione del punto di ingresso di ogni DLL associata con un valore che indica che il processo sta disconnettendo dalla DLL. Le DLL non ricevono notifiche quando un processo viene terminato da TerminateProcess. Per altre informazioni sulle DLL, vedere librerie Dynamic-Link.

Se un processo viene terminato da TerminateProcess, tutti i thread del processo vengono terminati immediatamente senza possibilità di eseguire codice aggiuntivo. Ciò significa che il thread non esegue il codice nei blocchi del gestore di terminazione. Inoltre, nessuna DLL associata riceve una notifica che indica che il processo è scollegato. Se è necessario che un processo termini un altro processo, la procedura seguente offre una soluzione migliore:

• Per creare un messaggio privato, entrambi i processi chiamano la funzione RegisterWindowMessage.

• Un processo può terminare l'altro processo trasmettendo un messaggio privato usando la funzioneBroadcastSystemMessagecome indicato di seguito:

   DWORD dwRecipients = BSM_APPLICATIONS;
      UINT uMessage = PM_MYMSG;
      WPARAM wParam = 0;
      LPARAM lParam = 0;
  
      BroadcastSystemMessage( 
          BSF_IGNORECURRENTTASK, // do not send message to this process
          &dwRecipients,         // broadcast only to applications
          uMessage,              // registered private message
          wParam,                // message-specific value
          lParam );              // message-specific value
  

• Il processo che riceve il messaggio privato chiama ExitProcess per terminare l'esecuzione.

L'esecuzione delle funzioni ExitProcess, ExitThread, CreateThread, CreateRemoteThreade CreateProcess è serializzata all'interno di uno spazio di indirizzi. Si applicano le restrizioni seguenti:

• Durante le routine di avvio del processo e di inizializzazione dll, è possibile creare nuovi thread, ma non iniziano l'esecuzione fino al termine dell'inizializzazione della DLL per il processo.
• Un solo thread alla volta può trovarsi in una routine di inizializzazione o scollegamento della DLL.
• La funzione ExitProcess non restituisce finché non ci sono più thread nelle routine di inizializzazione o scollegamento della DLL.