É a associação de mais de um fluxo de execução em um único processo.

Transcrição

1 Profa. Rita Rodorigo

2 Threads Um processo é uma abstração que reúne uma série de atributos como espaço de endereçamento descritores de arquivos abertos, quotas, etc. Um processo possui ainda uma área de código,dados e pilha de execução. Para cada processo é associado um fluxo de execução. Uma thread é um fluxo de execução de um processo. Unidade básica de utilização de CPU. A maioria dos processos possui apenas um fluxo de execução, ou seja, apenas uma thread. Consiste: ID de Processo Contador de Programa. (Program Counter) Registradores Pilha Compartilha com outras threads: Seção de código Seção de dados Recursos do SO

3 Multithreading É a associação de mais de um fluxo de execução em um único processo. As threads existem no interior de um processo. Compartilham o mesmo espaço, recursos, área de endereçamento do processo, código e dados. A gerência de threads ( criação, destruição, troca de contexto, sincronização) é mais leve comparada à gerência de processos). Um novo processo aloca e inicializa estrutura de dados no sistema operacional para representá-lo. Uma nova thread define uma nova pilha e um novo contexto de execução dentro do processo já existente. O chaveamento de duas threads é mais rápido que o chaveamento entre dois processos

4 Multithreading Benefícios Capacidade de Resposta Permite que um programa continue em execução, mesmo que parte dele esteja bloqueado ou executando uma tarefa demorada. Compartilhamento de Recursos Threads podem compartilhar recursos de memória e processador. Vários threads diferentes no mesmo espaço de endereçamento. Economia Alocar memória e processador é mais rápido para threads do que para processos. Arquitetura com múltiplos processadores Cada thread pode ser executado em paralelo em um processador diferente.

5 Programa exemplo de thread em C++ Threads são ideais para modelar o comportamento de diversos objetos do mundo real: os atores de um programa de simulação por exemplo. Se você está simulando o funcionamento de um banco, é interessante modelar cada caixa, cliente ou outros funcionários como objetos do tipo thread. Como se implementa isto?/* * BadClass.cpp * Sample code for "Multitasking Applications in Win32" * Shows the wrong way to try and start a thread * based on a class member function. * * THIS FILE IS NOT SUPPOSED TO COMPILE SUCCESSFULLY * You should get an error on line 51. */

6 /* * Member.cpp * Sample code for "Multithreading Applications in Win32" * This is from Chapter 9, Listing 9-3 shows how to start a thread based on * a class member function using a static member function. */ // Só os.h mais básicos serão incluídos. #define WIN32_LEAN_AND_MEAN #include <stdio.h> #include <stdlib.h> #include <windows.h> #include <process.h> typedef unsigned (WINAPI *PBEGINTHREADEX_THREADFUNC)(LPVOID lpthreadparameter); typedef unsigned *PBEGINTHREADEX_THREADID; // // This ThreadObject is created by a thread that wants to start another // thread. All public member functions except ThreadFunc() are called // by that original thread. The virtual function ThreadMemberFunc() is // the start of the new thread. // class ThreadObject { public: static ThreadObject(); void StartThread(); void WaitForExit(); DWORD WINAPI ThreadFunc(LPVOID param); protected: virtual DWORD ThreadMemberFunc(); HANDLE m_hthread; DWORD m_threadid; }; ThreadObject::ThreadObject() // Aqui nada muda { m_hthread = NULL; Threads in C++ 8 m_threadid = 0; }

7 void ThreadObject::StartThread() { m_hthread = (HANDLE)_beginthreadex(NULL, 0, (PBEGINTHREADEX_THREADFUNC) ThreadObject::ThreadFunc, (LPVOID)this, // passa pointer para objeto como parâmetro 0, (PBEGINTHREADEX_THREADID) &m_threadid ); if (m_hthread) { printf("thread launched\n"); } } void ThreadObject::WaitForExit() // Aqui nada muda { WaitForSingleObject(m_hThread, INFINITE); CloseHandle(m_hThread); } // // This is a static member function. Unlike C static functions, you only // place the static declaration on the function declaration in the class, not on // its implementation. // Static member functions have no "this" pointer, but do have access rights. // DWORD WINAPI ThreadObject::ThreadFunc(LPVOID param) { // Use the param as the address of the object ThreadObject* pto = (ThreadObject*)param; // Call the member function. Since we have a proper object pointer, even // virtual functions will be called properly. return pto->threadmemberfunc(); } // This above function ThreadObject::ThreadFunc() calls this function after // the thread starts up. DWORD ThreadObject::ThreadMemberFunc() // Função que desempenhará as funções da thread { // Do something useful... return 0; }

8 Exemplo: Um processador de Texto com 3 threads

9 Ciclo de Vida de Threads Estados Novo (Born) Pronto (Ready ou runnable) em Execução (Running) Terminado (Dead) Bloqueado (Blocked) Espera (Waiting) Adormecido (Sleeping)

10 Criação de thread Duas maneiras básicas podem ser utilizadas para implementar o conceito de thread. User-level threads O SO suporta processos convencionais, 1 thread por processo. Kernel threads A gerência de fluxo de execução do SO é orientada a threads e não a processos.

11 User-level thread Gerenciamento de Thread feito no nível do usuário Biblioteca de threads Suporte à criação, escalonamento e gerência Sem intervenção do Kernel Rápidos de criar e gerenciar Se o kernel tiver um único thread, sistema pode paralisar (thread bloqueante) Principais bibliotecas de threads POSIX Pthreads Java threads Win32 threads Mach C-threads Solaris threads

12 Kernel Thread Vantagens: Aproveita o paralelismo real e os processamentos de E/S. O SO deve ser projetado para considerar a existência de threads dividindo espaço de endereçamento no processo hospedeiro.

13 Suportadas diretamente pelo Kernel Criação, escalonamento e gerência feitos no espaço do Kernel Criação e gerência mais lentos que os threads de usuários Kernel sempre pode escalonar outro thread sistema nunca paralisa Kernel pode escalonar processos em outros processadores Exemplos Windows XP/2000 Solaris Linux Tru64 UNIX Mac OS X

14 Métodos de Múltiplas threads Muitos sistemas fornecem suporte a threads de usuário e kernel, resultando diferentes modelos de multithreading Modelo Muitos para um Modelo um para um Modelo Muitos para muitos

15 Modelo Muitos para Um N:1 Muitas threads do usuário associadas a uma única thread de kernel Exemplos: Solaris Green Threads GNU Portable Threads Eficiente, pois a gerência é feita no espaço do usuário Desvantagens Se houver chamada bloqueante o processo inteiro é bloqueado Não é possível executar múltiplos threads em multiprocessadores

16 N:1

17 Modelo um para um 1:1 Cada thread do usuário associada a uma thread de kernel Exemplos Windows NT/XP/2000 Linux Solaris 9 e acima Oferece mais concorrência Permite que outro thread execute quando um thread efetuar uma chamada bloqueante ao sistema Permite executar múltiplos threads em paralelo em multiprocessadores Desvantagem Criar um thread de usuário requer criar um thread de kernel Restrição no número de threads suportadas neste sistema

18 1:1

19 Método Misto M:N Uma biblioteca no espaço do usuário seleciona threads(m) do programa para serem executadas em uma ou mais threads (N) do sistema. O programador deve identificar o valor de (N) e decidir quantas threads (M) irá executar. Permite ao desenvolvedor criar tantos threads de usuário quanto desejar Os threads de Kernel correspondentes podem executar em paralelo em um multiprocessador Quando um thread efetuar uma chamada bloqueante ao sistema, o kernel pode escalonar outro thread para execução Desvantagem Verdadeira concorrência não é obtida Apenas um thread pode ser escalonado pelo kernel de cada vez

20 M:N

21

22

23

24

25 Um servidor web com múltiplos threads Figura extraída de Sistemas Operacionais Modernos Figura extraída de Sistemas Operacionais Modernos A.Tanenbaum; 2a Edição;

26 Notas da Intel Novas Ferramentas da Intel Ajudam os Desenvolvedores a Criar, Testar e Calibrar Aplicações Para o Windows Vista e Para os Mais Novos Processadores Multi-Core

27 Executar múltiplas tarefas simultaneamente também é conhecido como "rodar em paralelo." O paralelismo é acessado no hardware e nos sistemas operacionais com o conceito de threads de execução, que são mais fáceis de programar quando um resumo dos conceitos de paralelismo de dados e tarefas é inserido no software. Os produtos para o desenvolvimento de software da Intel são os mais novos exemplos do compromisso da companhia para simplificar a programação paralela e representam uma maneira eficiente para que as equipes de desenvolvimento preparem aplicações para processadores multi-core. Esses produtos asseguram que as aplicações threaded sejam escaláveis, confiáveis e otimizadas para as atuais e futuras inovações dos processadores.

28 O Intel Thread Checker 3.1 para Windows e Linux detecta erros nos códigos do paralelismo, para que os desenvolvedores possam introduzir o threading com mais segurança e rapidez. Com o seu avançado mecanismo patenteado de proteção a erros, o produto oferece "segurança thread" ao identificar os erros de threading mais obscuros em aplicações de 64 bits. Essa ferramenta é melhorada com desempenho otimizado para medição do tamanho de imagens e para o cálculo do tempo de execução de uma operação completa, o que oferece aos desenvolvedores análises ainda mais rápidas.

29 O Intel Thread Profiler 3.1 para Windows oferece aos desenvolvedores uma visão de como os threads para aplicações se comportam, e apontam problemas de desempenho paralelo como os gargalos de tráfego. Ele permite que os desenvolvedores calculem o número de núcleos que são utilizados eficientemente pela aplicação e indica o percentual do código que não está otimizado para o paralelismo da plataforma de hardware onde a aplicação está sendo executada. Essa versão atualizada agora oferece um caminho selecionável para análises e visualizações mais rápidas, além de oferece maior facilidade para a utilização repetitiva, por meio do suporte para a repetição automática de conjuntos de configurações personalizadas dentro de uma atividade. Esse produto atualizado aumenta a consistência e economiza o tempo dos desenvolvedores em tarefas repetitivas.