Threads em C

Threads em C

Aula sobre Threads em C

B1412c9ed55333c1df561f64dfad69d3?s=128

Gustavo Pantuza

October 15, 2014
Tweet

Transcript

  1. Redes de Computadores Threads Gustavo Pantuza Departamento de Ciência da

    Computação - UFMG 15 de Outubro, 2014
  2. Introdução Processos Threads Sincronização Redes Perguntas Processos Gustavo Pantuza Threads

  3. Introdução Processos Threads Sincronização Redes Perguntas Processos Um Processo é

    basicamente um programa em execução Um programa é apenas o código. Um programa pode executar vários processos Associado a cada processo está seu espaço de endereçamento Gustavo Pantuza Threads
  4. Introdução Processos Threads Sincronização Redes Perguntas Espaço de endereçamento Contém

    o programa executável e os recursos do programa. Recursos como: registradores (contador de progra e ponteiro para a pilha); lista de arquivos abertos; alarmes abertos (eventos e signals do SO); processos relacionados; Gustavo Pantuza Threads
  5. Introdução Processos Threads Sincronização Redes Perguntas Threads É a menor

    unidade de processamento de um processo, um fluxo de controle. Cada processo tem um espaço de endereçamento e, no mínimo, uma thread. Um processo tem duas partes: Ativa: fluxo de controle e execução (Thread) Passiva: espaço de endereçamento Threads de um mesmo processo compartilham do mesmo espaço de endereçamento. Gustavo Pantuza Threads
  6. Introdução Processos Threads Sincronização Redes Perguntas Processo com uma Thread

    Gustavo Pantuza Threads
  7. Introdução Processos Threads Sincronização Redes Perguntas Lista encadeada de processos

    Gustavo Pantuza Threads
  8. Introdução Processos Threads Sincronização Redes Perguntas Processos versus Threads O

    Linux escalona Tarefas (tasks) As tarefas são threads ou processos single-threaded Um processo é um conjunto de threads compartilhando o mesmo espaço de endereçamento O escalonador de tarefas do Linux não diferencia threads de processos Gustavo Pantuza Threads
  9. Introdução Processos Threads Sincronização Redes Perguntas Task structure 1 struct

    task_struct { 2 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */ 3 long counter, priority; 4 unsigned long signal; 5 unsigned long blocked; /* bitmap of masked signals */ 6 unsigned long flags; /* per process flags, defined below */ 7 struct task_struct *next_task, *prev_task, *next_run, *prev_run; 8 unsigned long saved_kernel_stack; 9 int pid, pgrp; 10 struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr; 11 unsigned long timeout, policy, rt_priority; 12 long utime, stime, cutime, cstime, start_time; 13 struct files_struct *files; /* open file information */ 14 struct mm_struct *mm; /* memory management info */ 15 struct signal_struct *sig; /* signal handlers */ 16 }; Figura: task_struct usada na lista de processos Gustavo Pantuza Threads
  10. Introdução Processos Threads Sincronização Redes Perguntas Transição de estados dos

    processos Gustavo Pantuza Threads
  11. Introdução Processos Threads Sincronização Redes Perguntas Criando novos processos (clones)

    Gustavo Pantuza Threads
  12. Introdução Processos Threads Sincronização Redes Perguntas Fork Gustavo Pantuza Threads

  13. Introdução Processos Threads Sincronização Redes Perguntas Fork example 1 #include

    <stdio.h> 2 #include <stdlib.h> 3 #include <unistd.h> /* fork */ 4 #define CHILD 0 5 int main(int argc, char* argv[]) 6 { 7 int num = 0; 8 /*Fork return the Child process id (PID) to Parent process. 9 * The child process pid variable must be 0 */ 10 int pid = fork(); 11 fprintf(stdout,"Both process run this line where number is: %d\n", num); 12 if(pid == CHILD){ /* Child Process */ 13 num = 1; 14 fprintf(stdout, "I am the CHILD and the number now is %d\n", num); 15 }else if(pid > 0){ /* Parent Process */ 16 num = 2; 17 fprintf(stdout, "I am the PARENT and the number now is %d\n", num); 18 } 19 printf("Who am I? the number for me is %d\n", num); return EXIT_SUCCESS; 20 } Figura: Very simple fork() example Gustavo Pantuza Threads
  14. Introdução Processos Threads Sincronização Redes Perguntas Fork utilizando wait() 1

    int main() { 2 pid_t childpid; /* variable to store the child’s pid */ 3 int retval; /* child process: user-provided return code */ 4 int status; /* parent process: child’s exit status */ 5 childpid = fork(); 6 if (childpid >= 0) { /* fork succeeded */ 7 if (childpid == 0) { /* fork() returns 0 to the child process */ 8 printf("CHILD: Here’s my PID: %d\n", getpid()); 9 sleep(1); printf("CHILD: Enter an exit value (0 to 255): "); 10 scanf(" %d", &retval); printf("CHILD: Goodbye!\n"); 11 exit(retval); /* child exits with user-provided return code */ 12 } else { /* fork() returns new pid to the parent process */ 13 printf("PARENT: Here’s my PID: %d\n", getpid()); wait(&status); 14 printf("PARENT: Child’s exit code: %d\n", WEXITSTATUS(status)); 15 printf("PARENT: Goodbye!\n"); exit(EXIT_SUCCESS); 16 } 17 } else { /* fork returns -1 on failure */ 18 perror("fork"); exit(EXIT_FAILURE); 19 } 20 } Figura: fork() example with wait() Gustavo Pantuza Threads
  15. Introdução Processos Threads Sincronização Redes Perguntas System call System call

    para criação de processos (fork()) 1 clone(SIGCHLD, 0); System call para criação de threads (pthread) 1 clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, 0); Gustavo Pantuza Threads
  16. Introdução Processos Threads Sincronização Redes Perguntas Threads Gustavo Pantuza Threads

  17. Introdução Processos Threads Sincronização Redes Perguntas Processo com multi threads

    Gustavo Pantuza Threads
  18. Introdução Processos Threads Sincronização Redes Perguntas Criando Threads Utiliza a

    lib pthread.h A função pthread_create() cria uma thread dentro do processo. A função passada como parâmetro é o bloco a ser executado pela thread A função pthread_join() aguarda até que a thread finalize sua execução Gustavo Pantuza Threads
  19. Introdução Processos Threads Sincronização Redes Perguntas Criando threads com pthread

    1 typedef struct str_thdata { 2 int thread_no; 3 char message[100]; 4 } thdata; 5 int main() { 6 pthread_t thread1, thread2; /* thread variables */ 7 thdata data1, data2; /* structs to be passed to threads */ 8 /* initialize data to pass to thread 1 and 2 */ 9 data1.thread_no = 1; 10 strcpy(data1.message, "Hello!"); 11 data2.thread_no = 2; 12 strcpy(data2.message, "Hi!"); 13 /* create threads 1 and 2 */ 14 pthread_create (&thread1, NULL, (void *) &print_msg, (void *) &data1); 15 pthread_create (&thread2, NULL, (void *) &print_msg, (void *) &data2); 16 /* Waits for threads to finish */ 17 pthread_join(thread1, NULL); 18 pthread_join(thread2, NULL); 19 exit(0); 20 } Figura: exemplo com pthread Gustavo Pantuza Threads
  20. Introdução Processos Threads Sincronização Redes Perguntas Barreira Gustavo Pantuza Threads

  21. Introdução Processos Threads Sincronização Redes Perguntas Barreira Barreira é um

    ponto de parada na execução do programa Qualquer process/thread é obrigado a parar na barreira Nenhum dos processos ou threads pode continuar até que todos os outros também tenham alcançados a barreira Gustavo Pantuza Threads
  22. Introdução Processos Threads Sincronização Redes Perguntas Workflow com Barreira Gustavo

    Pantuza Threads
  23. Introdução Processos Threads Sincronização Redes Perguntas Utilizando barreiras com pthread

    1 #define N_THREADS 10 2 pthread_barrier_t barrier; 3 void* print_num (void *data) { 4 fprintf(stdout, "thread %u: reached the barrier\n", (unsigned long) ← pthread_self()); 5 pthread_barrier_wait(&barrier); sleep(1); 6 fprintf(stdout, "thread %u: Now running ...\n", (unsigned long) ← pthread_self()); 7 } 8 int main (int argc, char *argv[]) { 9 pthread_barrier_init(&barrier, NULL, N_THREADS); 10 pthread_t threads[N_THREADS]; int i = 0; 11 for (;i < N_THREADS; i++) { 12 pthread_create(&threads[i], NULL, &print_num, NULL); 13 } 14 for (i=0; i < N_THREADS; i++) { 15 pthread_join(threads[i], NULL); 16 } 17 return EXIT_SUCCESS; 18 } Figura: Exemplo de Barreira Gustavo Pantuza Threads
  24. Introdução Processos Threads Sincronização Redes Perguntas Mutex Gustavo Pantuza Threads

  25. Introdução Processos Threads Sincronização Redes Perguntas Condição de corrida O

    resultado da computação em dois processos que compartilham um mesmo recurso depende de quem executa primeiro Ex: Duas threads tentanto alterar a mesma variável. As partes de um programa que acessam esses recursos compartilhados são chamadas de regiões críticas. Gustavo Pantuza Threads
  26. Introdução Processos Threads Sincronização Redes Perguntas Exclusão Mútua Para permitir

    que programas executem de maneira segura suas regiões críticas é necessário utilizar o princípio de Exclusão Mútua. Ela é uma forma de impedir que outros processos/threads façam uso de algum recurso compartilhado quando um processo o estiver usando. Ex: Só uma thread usa a variável por vez O mutex é uma implementação da Exclusão Mútua Gustavo Pantuza Threads
  27. Introdução Processos Threads Sincronização Redes Perguntas Exemplo utilizando Mutex 1

    pthread_mutex_t mutex; 2 void* modify_num (void *data) { 3 sleep(3); int *num = (int *) data; 4 pthread_mutex_lock(&mutex); /* Critical region */ *num = 0; 5 fprintf(stdout, "thread %d: Entering critical region\n",pthread_self()); 6 fprintf(stdout, "I’m a bad thread. Nobody move! num is now %d\n", *num); 7 sleep(3); pthread_mutex_unlock(&mutex); 8 fprintf(stdout, "thread %d: Exiting critical region\n", pthread_self()); 9 } 10 int main (int argc, char *argv[]) { 11 pthread_mutex_init(&mutex, NULL); pthread_t thread; int num = 0; 12 pthread_create(&thread, NULL, &modify_num, (void *) &num); 13 for (int i = 0; i < N_ITERATIONS; i++) { 14 pthread_mutex_lock(&mutex); 15 fprintf(stdout, "num is %d\n", num++); 16 pthread_mutex_unlock(&mutex); sleep(1); 17 } 18 pthread_join(thread, NULL); pthread_mutex_destroy(&mutex); 19 return EXIT_SUCCESS; 20 } Figura: Exemplo de Mutex Gustavo Pantuza Threads
  28. Introdução Processos Threads Sincronização Redes Perguntas Semáforo Gustavo Pantuza Threads

  29. Introdução Processos Threads Sincronização Redes Perguntas Semáforo Implementa a Exclusão

    Mútua Um Mutex gera Espera Ocupada A Espera Ocupada é quando um processo verifica uma condição repetidamente até que ela seja verdadeira Ela ocupa o processador junto com os demais processos. Ineficiente Semáforos colocam o processo pra dormir (wait state) O processo é acordado quando o semáforo é incrementado Gustavo Pantuza Threads
  30. Introdução Processos Threads Sincronização Redes Perguntas Exemplo utilizando Semáforo 1

    #define THREADS 20 2 #define N_MILKS 4 3 sem_t OKToBuyMilk; int milkAvailable; 4 void* buyer(void *arg) { 5 sem_wait(&OKToBuyMilk); 6 if(milkAvailable < N_MILKS) 7 ++milkAvailable; 8 sem_post(&OKToBuyMilk); return NULL; 9 } 10 int main(int argc, char **argv) { 11 pthread_t threads[THREADS]; milkAvailable = 0; 12 sem_init(&OKToBuyMilk, 0, 1); 13 for(int i = 0; i < THREADS; ++i) 14 pthread_create(&threads[i], NULL, &buyer, NULL); 15 for(int i = 0; i < THREADS; ++i) 16 pthread_join(threads[i], NULL); 17 sem_destroy(&OKToBuyMilk); 18 printf("Total milk: %d\n", milkAvailable); 19 return EXIT_SUCCESS; 20 } Figura: Exemplo de Semáforo Gustavo Pantuza Threads
  31. Introdução Processos Threads Sincronização Redes Perguntas Threads em requisições em

    rede Gustavo Pantuza Threads
  32. Introdução Processos Threads Sincronização Redes Perguntas Threads em requisições em

    rede Imagine uma arquitetura cliente/servidor utilizando sockets O servidor pode criar threads para lidar com as requisições recebidas Gustavo Pantuza Threads
  33. Introdução Processos Threads Sincronização Redes Perguntas Threads em requisições em

    rede 1 void handler(void * paramsd) { 2 ... 3 while(readnf(client_local, line)!=ERROR) 4 { 5 /* Process the request send() recv() */ 6 } 7 } 8 9 int main (int argc, char* argv[]) { 10 ... 11 while(1) { 12 addr_len = sizeof(cliAddr); 13 client = accept(server, (struct sockaddr *) &cliAddr, (socklen_t *)&← addr_len); 14 pthread_create(&thread, 0, (void*)&handler, (void*) &client); 15 } 16 } Figura: Exemplo utilizando threads para manipular requisições Gustavo Pantuza Threads
  34. Introdução Processos Threads Sincronização Redes Perguntas Dúvidas? Contatos: email: gustavopantuza@gmail.com

    github: pantuza twitter: @gpantuza site: http://pantuza.com Gustavo Pantuza Threads