Condividi tramite

Controllo di processi e thread

Quando si esegue il debug in modalità utente, è possibile attivare, visualizzare, bloccare, sbloccare, sospendere e riattivare processi e thread.

Il processo corrente o attivo è il processo attualmente in corso 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 corrente. Il processo corrente determina anche le mappature degli indirizzi virtuali usate dal debugger.

All'inizio del debug, il processo corrente è quello a cui è collegato 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 sul modo in cui i processi e i thread vengono modificati in modalità kernel, vedere Changing Contexts.For more information about how processes and threads are manipulated in kernel mode, see Changing Contexts.

Visualizzazione di processi e thread

Per visualizzare le 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:

Congelamento 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 è maggiore o uguale a uno, il sistema non esegue il thread. Se il conteggio è zero o inferiore, il sistema esegue il thread quando opportuno.

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

È 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 di questi comandi è aumentare il conteggio delle sospensioni 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, "congelato" è semplicemente un'impostazione del debugger. Niente nel sistema operativo Windows riconosce che qualcosa sia diverso in questo thread.

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

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

In ogni caso, i thread che appartengono al processo di destinazione non vengono mai eseguiti quando il debugger è intervenuto sul processo di destinazione. Il conteggio delle sospensioni 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 di altri comandi

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

È possibile aggiungere il qualificatore ~e (Thread-Specific Command) prima di molti comandi e comandi di estensione. 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ù obiettivi 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.

  • Last updated on