Thread o que é como funciona?

Uma thread é basicamente uma linha de execução independente, contida dentro de um processo. Ou seja, uma thread permite que um processo "faça varias coisas de forma simultânea", já que um processo pode conter várias threads. Todas as threads que fazem parte de um mesmo processo compartilham vários recursos, como o espaçamento de memória e os handles. Ou seja, elas acessam as mesmas variávies e podem usar os mesmos handles ao mesmo tempo.

Quando um processo é criado no Windows, é criado junto com ele a thread principal, que é thread que roda a função main ou WinMain. A partir daí é possível criar novas threads.

A única diferença entre as threads criadas posteriormente e a thread principal de um processo é que quando a thread principal acaba, todas as outras threads são forçosamente terminadas e o processo acaba - caso contrário uma thread esquecida poderia deixar o processo em um estado de limbo. Em um computador rodando Windows, em uma determinada hora, temos várias threads rodando, e a thread é única entidade que faz uso do processador. No Windows, um processo não "roda" nem é executado. O que "roda" é uma thread (que por sua vez pertence à um processo). Dessa forma, o scheduler (agendador) do Windows trabalha compartilhando e dividindo o uso do processador entre as threads do sistema, independente do processo que contém a thread.
Em uma de suas atuações, o scheduler do Windows (e de qualquer SO) funciona basicamente respondendo à uma interrupção de timer que acontece em intervalos de milissegundos. Quando essa interrupção ocorre, a thread atual é interrompida, e o scheduler toma seu lugar no processador para verificar se é necessário trocar de thread. Caso o quantum (tempo de cpu determinado para que a thread rode antes de outra thread assumir o processador) da thread atual tenha terminado, o scheduler salva os registradores que definem o estado atual da thread no thread context (veja a estrutura _CONTEXT no winnt.h) e carrega os registradores da próxima thread a ser executada. Com a nova thread pronta para utilizar o processador, o scheduler coloca a thread atual no fim da fila. Falando em código, o ponteiro da estrutura ETHREAD que representa a thread é colocada no fim de uma lista duplamente ligada que controla a fila de threads em estado ready.
Quando só existe um processador ou core no computador, o scheduler dá a impressão de que as threads estão sendo executadas simultaneamente, alternando entre elas dessa forma. Quando mais de um processador ou core estão disponíves, várias threads podem ser executadas simultaneamente, o que faz com que o scheduler precise distribuir as threads entre os N processadores disponíveis.
O tempo de interrupção citado é de 20 à 120ms, dependendo do processador e da versão do Windows. Nas versões Home, Professional e Business, os intervalos são de 20ms, para que o sistema seja mais responsivo ao usuário interativo. O intervalo de 120ms é usado nas versões Server, pois quanto maior o quantum, maior a probabilidade da thread conseguir atender a requisição em um quantum só, aumentando a vazão do servidor.
Outra situação onde o scheduler aparece é quando uma thread deve esperar uma operação de I/O. Nesse caso a thread perde o controle do processador antes que seu quantum acabe, e ela só será colocada novamente na lista de threads ready (prontas para serem executadas) quando essa requisição de I/O for respondida.
Como sempre, mais informações podem ser encontradas na MSDN (sobre as funções CreateThread e WaitForXXX), Wikipedia (sobre conceitos do sistemas operacionais, como quantum e thread) e no livro "Windows Internals" (sobre a implementação dos conceitos no kernel do Windows).
Fonte:http://www.1bit.com.br/content.1bit/weblog/win32_threads