Condividi tramite

Controllo di processi e thread

  • Articolo

Quando si esegue il debug in modalità utente, è possibile attivare, visualizzare, bloccare, sbloccare, sospendere e annullare la sospensione di processi e thread non sospesi.

Il processo corrente o attivo è il processo in fase di debug. Analogamente, il thread corrente o attivo è il thread attualmente controllato dal debugger. Le azioni di molti comandi del debugger sono determinate dall'identità del processo e del thread correnti. Il processo corrente determina anche i mapping degli indirizzi virtuali usati dal debugger.

All'avvio del debug, il processo corrente è quello a cui è associato il debugger o che ha causato l'eccezione che si è interrotta nel debugger. Analogamente, il thread corrente è quello attivo quando il debugger è collegato al processo o che ha causato l'eccezione. È tuttavia possibile usare il debugger per modificare il processo e il thread correnti e per bloccare o sbloccare singoli thread.

Nel debug in modalità kernel, i processi e i thread non sono controllati dai metodi descritti in questa sezione. Per altre informazioni su come i processi e i thread vengono modificati in modalità kernel, vedere Modifica dei contesti.

Visualizzazione di processi e thread

Per visualizzare informazioni sui processi e sui thread, è possibile usare i metodi seguenti:

Impostazione del processo e del thread correnti

Per modificare il processo o il thread corrente, è possibile usare i metodi seguenti:

Blocco e sospensione di thread

Il debugger può modificare l'esecuzione di un thread sospendendo il thread o bloccando il thread. Queste due azioni hanno effetti leggermente diversi.

A ogni thread è associato un conteggio di sospensione . Se questo conteggio è uno o più grandi, il sistema non esegue il thread. Se il conteggio è zero o inferiore, il sistema esegue il thread quando appropriato.

In genere, ogni thread ha un conteggio di sospensione pari a zero. Quando il debugger si connette a un processo, incrementa di uno i conteggi di sospensione di tutti i thread in tale processo. Se il debugger si disconnette dal processo, decrementa tutti i conteggi di sospensione di uno. Quando il debugger esegue il processo, decrementa temporaneamente tutti i conteggi di sospensione di uno.

È possibile controllare il numero di sospensioni di qualsiasi thread dal debugger usando i metodi seguenti:

  • Il comando ~n (Suspend Thread) incrementa il conteggio di sospensione del thread specificato di uno.

  • Il comando ~m (Resume Thread) decrementa il conteggio di sospensione del thread specificato di uno.

L'uso più comune per questi comandi consiste nel generare il conteggio di sospensione di un thread specifico da uno a due. Quando il debugger viene eseguito o disconnesso dal processo, il thread ha un conteggio di sospensione di uno e rimane sospeso, anche se vengono eseguiti altri thread nel processo.

È possibile sospendere i thread anche quando si esegue il debug non invasivo.

Il debugger può anche bloccare un thread. Questa azione è simile alla sospensione del thread in alcuni modi. Tuttavia, "bloccato" è solo un'impostazione del debugger. Nessun elemento nel sistema operativo Windows riconosce che qualsiasi elemento è diverso rispetto a questo thread.

Per impostazione predefinita, tutti i thread sono non gestiti. Quando il debugger causa l'esecuzione di un processo, i thread bloccati non vengono eseguiti. Tuttavia, se il debugger si scollega dal processo, tutti i thread non vengono sbloccati.

Per bloccare e sbloccare singoli thread, è possibile usare i metodi seguenti:

In qualsiasi caso, i thread che appartengono al processo di destinazione non vengono mai eseguiti quando il debugger è suddiviso nella destinazione. Il conteggio di sospensione di un thread influisce sul comportamento del thread solo quando il debugger esegue il processo o si scollega. Lo stato bloccato influisce sul comportamento del thread solo quando il debugger esegue il processo.

Thread e processi in altri comandi

È possibile aggiungere identificatori di thread o identificatori di processo prima di molti altri comandi. Per altre informazioni, vedere i singoli argomenti relativi ai comandi.

È possibile aggiungere il qualificatore ~e (comando specifico del thread) prima di molti comandi ed estensioni. Questo qualificatore fa sì che il comando venga eseguito rispetto al thread specificato. Questo qualificatore è particolarmente utile se si vuole applicare un comando a più thread. Ad esempio, il comando seguente ripete il comando di estensione !gle per ogni thread di cui viene eseguito il debug.

~*e !gle

Più sistemi

Il debugger può connettersi a più destinazioni contemporaneamente. Quando questi processi includono file di dump o includono destinazioni attive in più computer, il debugger fa riferimento a un sistema, un processo e un thread per ogni azione. Per altre informazioni su questo tipo di debug, vedere Debug di più destinazioni.