Condivisione della tecnologia

Linguaggio C: operazioni di concorrenza avanzate (thread)

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Il concetto di filo

Thread: un'entità in un processo e l'unità di base della pianificazione e del dispatch della CPU. Il thread in sé fondamentalmente non possiede risorse di sistema, solo poche risorse essenziali per l'esecuzione (come un contatore di programmi, un insieme di registri e uno stack), ma può condividere tutte le risorse possedute dal processo con altri thread che appartengono allo stesso processo. Un thread può creare e distruggere un altro thread più thread nello stesso processo possono essere eseguiti contemporaneamente. I thread mostrano un comportamento intermittente durante il funzionamento. (Quanto sopra è tratto da "Tutorial di livello 4 per computer - Principi del sistema operativo")

Quando si parla di thread, è necessario parlare della definizione di processo: un processo è un programma con determinate funzioni indipendenti. Un processo è un'unità indipendente per l'allocazione e la pianificazione delle risorse nel sistema. (Quanto sopra è tratto da "Tutorial di livello 4 per computer - Principi del sistema operativo")

La definizione di processo è un po' contorta. Vediamo in cosa consiste un processo: programma, dati e blocco di controllo del processo. Tra questi, il programma corrisponde nella definizione del processo a "un programma con determinate funzioni indipendenti". Tuttavia, oltre al programma stesso, il processo necessita anche di dati (che possono essere intesi come risorse) e di blocchi di controllo del processo. I blocchi di controllo dei dati e dei processi sono risorse essenziali quando un programma è in esecuzione. Il programma fa affidamento su queste risorse per eseguire le attività corrispondenti, che è ciò che chiamiamo "processo".

Due proprietà fondamentali dei processi:

Un processo è un'unità indipendente che può possedere risorse;
Un processo è un'unità di base che può essere pianificata e distribuita in modo indipendente.
Quando i thread furono stabiliti per la prima volta, fu necessario separare i due attributi precedenti del processo. I thread costituiscono "l'unità base della pianificazione e dell'invio della CPU". In questo modo, possono esserci molti thread in un processo e il sistema operativo può eseguire la pianificazione e inviare thread in modo migliore Può realizzare l'esecuzione parallela di processi; allo stesso tempo, i thread nello stesso processo possono condividere tutte le risorse del processo, il che può soddisfare l'accesso alle risorse del processo da parte di thread diversi nello stesso processo. L'emergere di thread separa abilmente i due attributi del processo, consentendo al processo di gestire meglio le esigenze dell'esecuzione parallela.

Un thread è una funzione in esecuzione. I thread POSIX sono un insieme di standard, non un insieme di implementazioni. Esistono altri standard come: thread openmp.
Identificatore del thread: pthread_t (non conosco il contenuto specifico, ogni azienda lo implementa in modo diverso, sotto Linux è int)
Il comando px axm vede processi e thread, che rappresentano i thread sotto un processo. px ax -L per visualizzare thread leggeri.

int pthread_equal(pthread_t t1, pthread_t t2); Confronta i numeri ID di due thread. Se sono uguali, viene restituito un valore diverso da zero; se sono diversi, viene restituito 0.
pthread_t pthread_self(void); Ottieni l'ID del thread corrente

2. Creazione di thread

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*routine_di_avvio) (void *), void *arg);
La pianificazione dei thread dipende dalla strategia dello scheduler.

creare1.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5.  
  6. void* myfunc(void *p)
  7. {
  8.     puts("Thread is run!");
  9.  
  10.     printf("thread %ld n",pthread_self());
  11.     return NULL;
  12. }
  13.  
  14. int main()
  15. {
  16.     puts("Begin!");
  17.     pthread_t tid;
  18.     int ret;
  19.     ret = pthread_create(&tid,NULL,myfunc ,NULL);
  20.     if(ret)
  21.     {
  22.         fprintf(stderr,"%s n",strerror(ret));
  23.         exit(1);
  24.     }
  25.     printf("main %ld n",pthread_self());
  26.  
  27.  
  28.  
  29.     puts("End!");
  30. }

Terminazione del thread

1. Il thread ritorna dalla routine di avvio e il valore restituito è il codice di uscita del thread.
2. I thread possono essere annullati da altri thread nello stesso processo.
3. Il thread chiama la funzione pthread_exit(). void pthread_exit(void *retval);

int pthread_join(pthread_t thread, void **retval); Equivale all'attesa del processo e viene utilizzato per raccogliere i cadaveri.

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5.  
  6. void* myfunc(void *p)
  7. {
  8.     puts("Thread is run!");
  9.  
  10.     pthread_exit(NULL);//线程专用清理函数。
  11. //    return NULL;
  12. }
  13.  
  14.  
  15. int main()
  16. {
  17.     puts("Begin!");
  18.     pthread_t tid;
  19.     int ret;
  20.     ret = pthread_create(&tid,NULL,myfunc ,NULL);
  21.     if(ret)
  22.     {
  23.         fprintf(stderr,"%s n",strerror(ret));
  24.         exit(1);
  25.     }
  26.     pthread_join(tid,NULL); //收尸
  27.  
  28.     puts("End!");
  29. }

pulizia dello stack

pthread_cleanup_push(); //Equivalente a atexit
pthread_cleanup_pop(); //Equivalente al recupero attivo dei dati.

void pthread_cleanup_push(void (*routine)(void *), è l'implementazione della macro, gcc -E per visualizzare la preelaborazione
vuoto *argomento);
void pthread_cleanup_pop(int eseguite); //Scegli se chiamare.Deve apparire in coppia, implementato con macro

pulizia.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5.  
  6.  
  7. void cleanup_fun(void*p)
  8. {
  9.     puts(p);
  10. }
  11.  
  12. void* myfunc(void *p)
  13. {
  14.     puts("Thread is run!");
  15.     
  16.     pthread_cleanup_push(cleanup_fun,"cleanup:1");
  17.     pthread_cleanup_push(cleanup_fun,"cleanup:2");
  18.     pthread_cleanup_push(cleanup_fun,"cleanup:3");
  19.     
  20.     puts("push over!");
  21.  
  22.  
  23.  
  24.     pthread_exit(NULL);//线程专用清理函数。
  25. //    return NULL;
  26.     pthread_cleanup_pop(1) //线程退出后，全部都会调用;
  27.     pthread_cleanup_pop(0);
  28.     pthread_cleanup_pop(1);
  29. }
  30.  
  31.  
  32. int main()
  33. {
  34.     puts("Begin!");
  35.     pthread_t tid;
  36.     int ret;
  37.     ret = pthread_create(&tid,NULL,myfunc ,NULL);
  38.     if(ret)
  39.     {
  40.         fprintf(stderr,"%s n",strerror(ret));
  41.         exit(1);
  42.     }
  43.     pthread_join(tid,NULL); //收尸
  44.  
  45.     puts("End!");
  46. }

Annulla le opzioni per i thread

Se il thread in esecuzione vuole raccogliere il cadavere, deve prima annullare (pthread_cancel) e poi raccogliere il cadavere (pthread_join).

Cancellazione del thread: int pthread_cancel(pthread_t thread);
La cancellazione ha due stati: consentito e non consentito.
Cancellazione non consentita: l'esecuzione del codice continua inalterata.
L'annullamento consentito è suddiviso in: annullamento asincrono e annullamento ritardato (impostazione predefinita) -&gt; risposta ritardata fino al punto di annullamento.
Punto di cancellazione: i punti di cancellazione definiti da Posix sono chiamate di sistema che possono causare congestione.
pthread_setcancelstate: è possibile impostare lo stato di annullamento.
pthread_setcanceltype: puoi impostare il metodo di cancellazione.
pthread_testcancel: la funzione non fa nulla, cancella solo il punto.

Distacco del thread: int pthread_detach(pthread_t thread);

Funzione di inizializzazione singola del modulo dinamico: int pthread_once(pthread_once_t *once_control,
vuoto (*init_routine)(vuoto));
pthread_once_t once_control = PTHREAD_ONCE_INIT;
 

Esempio 1
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #define LEFT  30000000
  7. #define RIGHT 30000200
  8. #define THRNUM (RIGHT-LEFT+1)
  9.      
  10. void* thr_prime(void*p);
  11.  
  12. int main()
  13. {
  14.     pthread_t tid[THRNUM];
  15.     int i,j,mark;
  16.    int err; 
  17.     for(i =LEFT;i<=RIGHT;i++)
  18.     {
  19.         err= pthread_create(tid+(i-LEFT),NULL,thr_prime,&i);
  20.         if(err)
  21.         {
  22.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  23.         }
  24.     }
  25.  
  26.     for(i=LEFT;i<=RIGHT;i++)
  27.     {
  28.         pthread_join(tid[i-LEFT],NULL);
  29.     }
  30.     
  31.     return 0;
  32. }
  33.  
  34. void* thr_prime(void*p)
  35. {
  36.     int i,j,mark;
  37.  
  38.     i = *(int*)p;
  39.  
  40.     mark = 1;
  41.     for(j=2;j<i/2;j++)
  42.     {
  43.         if(i%j ==0)
  44.         {
  45.             mark = 0;
  46.             break;
  47.         }
  48.     }
  49.     if(mark)
  50.         printf("%d is a primer n",i);
  51.     pthread_exit(NULL);
  52.     return NULL;
  53.  }

Ci sarà competizione quando verrà eseguito il codice sopra. Poiché i parametri vengono passati per indirizzo, i dati devono essere recuperati da * e non vi è alcuna garanzia che il thread precedente abbia eseguito l'operazione. Il metodo più semplice consiste nell'utilizzare il passaggio del valore.

primer0.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #define LEFT  30000000
  7. #define RIGHT 30000200
  8. #define THRNUM (RIGHT-LEFT+1)
  9.      
  10. void* thr_prime(void*p);
  11.  
  12. int main()
  13. {
  14.     pthread_t tid[THRNUM];
  15.     int i,j,mark;
  16.    int err; 
  17.     for(i =LEFT;i<=RIGHT;i++)
  18.     {
  19.         err= pthread_create(tid+(i-LEFT),NULL,thr_prime,(void *)i);
  20.         // err= pthread_create(tid+(i-LEFT),NULL,thr_prime,&i);
  21.         if(err)
  22.         {
  23.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  24.         }
  25.     }
  26.  
  27.     for(i=LEFT;i<=RIGHT;i++)
  28.     {
  29.         pthread_join(tid[i-LEFT],NULL);
  30.     }
  31.     
  32.     return 0;
  33. }
  34.  
  35. void* thr_prime(void*p)
  36. {
  37.     int i,j,mark;
  38.  
  39.     i = (int)p;
  40.     // i = *(int*)p;
  41.  
  42.     mark = 1;
  43.     for(j=2;j<i/2;j++)
  44.     {
  45.         if(i%j ==0)
  46.         {
  47.             mark = 0;
  48.             break;
  49.         }
  50.     }
  51.     if(mark)
  52.         printf("%d is a primer n",i);
  53.     pthread_exit(NULL);
  54.     return NULL;
  55.  }

primer0_e.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6.  
  7. #define LEFT  30000000
  8. #define RIGHT 30000200
  9. #define THRNUM (RIGHT-LEFT+1)
  10.  
  11. struct thr_arg_st
  12. {
  13.     int n;
  14. };
  15.  
  16. void* thr_prime(void*p);
  17.  
  18. int main()
  19. {
  20.     pthread_t tid[THRNUM];
  21.     int i,j,mark;
  22.    int err;
  23.    struct thr_arg_st* p;
  24.     void *ptr;
  25.     for(i =LEFT;i<=RIGHT;i++)
  26.     {
  27.         p = malloc(sizeof(*p));
  28.         if(p ==NULL)
  29.         {
  30.             perror("malloc");
  31.             exit(1);
  32.         }
  33.         p->n  = i;
  34.         err= pthread_create(tid+(i-LEFT),NULL,thr_prime,p); // p就是结构体指针就是n的地址
  35.         // err= pthread_create(tid+(i-LEFT),NULL,thr_prime,&i);
  36.         if(err)
  37.         {
  38.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  39.         }
  40.         //free 不能在这里free，必须取走数据在free
  41.     }
  42.  
  43.     for(i=LEFT;i<=RIGHT;i++)
  44.     {
  45.         pthread_join(tid[i-LEFT],&ptr);// 收尸并且接受返回参数。
  46.         free(ptr);
  47.  
  48.     }
  49.     
  50.     return 0;
  51. }
  52.  
  53. void* thr_prime(void*p)
  54. {
  55.     int i,j,mark;
  56.  
  57.      i = ((struct thr_arg_st*)p)->n;
  58.  
  59.     mark = 1;
  60.     for(j=2;j<i/2;j++)
  61.     {
  62.         if(i%j ==0)
  63.         {
  64.             mark = 0;
  65.             break;
  66.         }
  67.     }
  68.     if(mark)
  69.         printf("%d is a primer n",i);
  70.     pthread_exit(p); //返回值返回p
  71.     return NULL;
  72.  }
Esempio 2

aggiungere.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6.  
  7. #define FILENAME  "/tmp/out"
  8. #define THRNUM (20)
  9.      
  10. void* thr_add(void*p);
  11.  
  12. int main()
  13. {
  14.     pthread_t tid[THRNUM];
  15.     int i,j,mark;
  16.    int err; 
  17.     for(i =0;i<=THRNUM;i++)
  18.     {
  19.         err= pthread_create(tid+(i),NULL,thr_add,NULL);
  20.         if(err)
  21.         {
  22.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  23.         }
  24.     }
  25.  
  26.     for(i=0;i<=THRNUM;i++)
  27.     {   
  28.         pthread_join(tid[i],NULL);
  29.     }
  30.     
  31.     return 0;
  32. }
  33.  
  34. void* thr_add(void*p)
  35. {
  36.     FILE*fp;
  37.     char line_buf[1024];
  38.     int len_size = 1024;
  39.     fp = fopen(FILENAME,"r+");
  40.     
  41.     fgets(line_buf,len_size,fp);
  42.     
  43.     fseek(fp,0,SEEK_SET);
  44.  
  45.     fprintf(fp,"%d n",atoi(line_buf)+1);
  46.    
  47.    fclose(fp);
  48.  
  49.     pthread_exit(NULL);
  50.  
  51.     return NULL;
  52.  }

Possono verificarsi competizione e conflitti quando venti thread leggono e scrivono dati in un file contemporaneamente. Prima che un thread scriva, un altro thread legge gli ultimi dati.

ilmiotbf.c
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <error.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9. #include <errno.h>
  10. #include <signal.h>
  11. #include <pthread.h>
  12.  
  13. #include "mytbf.h"
  14.  
  15. struct mytbf_st
  16. {
  17.     int cps;
  18.     int burst;
  19.     int token;
  20.     int pos;
  21. 	pthread_mutex_t mut;
  22. };
  23. static pthread_mutex_t mut_job = PTHREAD_MUTEX_INITIALIZER;
  24. static pthread_t tid_alrm;
  25. pthread_once_t init_once = PTHREAD_ONCE_INIT;
  26.  
  27. static struct mytbf_st* job[MYTBF_MAX];
  28.  
  29. typedef void (*sighandler_t)(int);
  30.  
  31.  
  32. static int get_free_pos_unlocked(void)
  33. {
  34.     for(int i=0;i< MYTBF_MAX;i++)
  35.     {
  36.         if(job[i]==NULL)
  37.             return i;
  38.     }
  39.     return -1;
  40. }
  41.  
  42. static void*  thr_alrm(void*p)
  43. {
  44. 	while(1)
  45. 	{
  46. 		pthread_mutex_lock(&mut_job);
  47. 		for(int i=0;i<MYTBF_MAX;i++)
  48. 		{
  49. 			if(job[i] != NULL)
  50. 			{
  51. 				pthread_mutex_lock(&job[i]->mut);
  52. 				job[i]->token += job[i]->cps;
  53. 				if(job[i]->token >job[i]->burst )
  54. 				{
  55. 					job[i]->token = job[i]->burst;
  56. 				}
  57. 				pthread_mutex_unlock(&job[i]->mut);
  58. 			}
  59. 		}
  60. 		pthread_mutex_unlock(&mut_job);
  61. 		sleep(1);
  62. 	}
  63.     return NULL;
  64. }
  65.  
  66. static void module_unload()
  67. {
  68. 	pthread_cancel(tid_alrm);
  69. 	pthread_join(tid_alrm,NULL);
  70. 	//只能一个人掉，二个人调用容易出差
  71.     for(int i=0;i<MYTBF_MAX;i++)
  72.     {
  73. 		if(job[i]!=NULL)
  74. 		{
  75. 			mytbf_destroy(job[i]);
  76. 		}
  77. 	}
  78. 	pthread_mutex_destroy(&mut_job);
  79.  
  80. }
  81.  
  82. static void module_load()
  83. {
  84.    int err;
  85.    err = pthread_create(&tid_alrm,NULL,thr_alrm,NULL);
  86. 	if(err)
  87. 	{
  88. 		fprintf(stderr,"create errorn");
  89. 		exit(1);
  90. 	}
  91.     atexit(module_unload);
  92. }
  93.  
  94. mytbf_t* mytbf_init(int cps ,int burst)  //C语言中，void*可以赋值给任何类型的指针，任何类型的指针也都可以赋值给void*
  95. {
  96.     struct mytbf_st*me;
  97.     int pos;
  98.     pthread_once(&init_once,module_load); //只初始化一次
  99. 	me = malloc(sizeof(*me));
  100.     if(me == NULL)
  101.         return NULL;
  102.  
  103.     me->cps = cps;
  104.     me->burst = burst;
  105.     me->token = 0;
  106.  
  107.     pthread_mutex_init(&me->mut,NULL);
  108. 	
  109. 	pthread_mutex_lock(&mut_job);
  110.    
  111.    pos = get_free_pos_unlocked();
  112.     if(pos < 0)
  113. 	{
  114. 	
  115. 		pthread_mutex_unlock(&mut_job);
  116.         free(me);
  117. 		return NULL;
  118. 	}
  119.     me->pos = pos;
  120.     job[pos] = me;
  121.  
  122. 	pthread_mutex_unlock(&mut_job);
  123.     
  124. 	return me;
  125.  
  126. }
  127. int mytbf_fetchtoken(mytbf_t*ptr,int size)  //获取token
  128. {
  129.     if(size <= 0)
  130.         return -EINVAL;  //参数非法
  131.     struct mytbf_st*me = ptr;
  132. 	pthread_mutex_lock(&me->mut);
  133.     while(me->token <= 0 )  //token为空就等待
  134. 	{
  135. 		pthread_mutex_unlock(&me->mut);
  136. 		sched_yield();
  137. 		pthread_mutex_lock(&me->mut);
  138. 	}
  139.     
  140.     int n = (me->token>size?size:me->token);
  141.     me->token -= n;
  142.     pthread_mutex_unlock(&me->mut);
  143. 	return n;
  144. }
  145.  
  146. int mytbf_returntoken(mytbf_t*ptr,int size)  //返还token
  147. {
  148.     if(size<=0)
  149.         return -EINVAL;
  150.     struct mytbf_st*me = ptr;
  151.  
  152.     pthread_mutex_lock(&me->mut);
  153. 		
  154.     me->token+= size;
  155.     if(me->token > me->burst)
  156.         me->token  = me->burst;
  157.  
  158.     pthread_mutex_unlock(&me->mut);
  159.     return size;
  160. }
  161.  
  162. int mytbf_destroy(mytbf_t*ptr)
  163. {
  164.     struct mytbf_st *me;
  165.     me = ptr;
  166. 	pthread_mutex_lock(&mut_job);
  167.     job[me->pos] = NULL;
  168. 	pthread_mutex_unlock(&mut_job);
  169. 	pthread_mutex_destroy(&me->mut);
  170. 	free(ptr);
  171.     return 0;
  172.     
  173. }

3. Sincronizzazione dei thread

mutex

È equivalente a una serratura, che deve essere sbloccata prima di poter essere azionata. (metodo di interrogazione)
Se man pthread_mutex_init segnala un errore, installa le dipendenze:
sudo apt-get install manpages-posix manpages-posix-dev

int pthread_mutex_destroy(pthread_mutex_t *mutex) //Distrugge il lucchetto
int pthread_mutex_init(pthread_mutex_t *limita mutex,
const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; inizializzazione statica

int pthread_mutex_lock(pthread_mutex_t *mutex); //Ripristina
int pthread_mutex_trylock(pthread_mutex_t *mutex);//Prova a bloccare, in caso contrario, continua l'esecuzione
int pthread_mutex_unlock(pthread_mutex_t *mutex);//Conferma

aggiungere.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6.  
  7. #define FILENAME  "/tmp/out"
  8. #define THRNUM (20)
  9.  
  10. pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
  11.  
  12. void* thr_add(void*p);
  13.  
  14. int main()
  15. {
  16.     pthread_t tid[THRNUM];
  17.     int i,j,mark;
  18.    int err; 
  19.     for(i =0;i<THRNUM;i++)
  20.     {
  21.         err= pthread_create(tid+(i),NULL,thr_add,NULL);
  22.         if(err)
  23.         {
  24.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  25.         }
  26.     }
  27.  
  28.     for(i=0;i<THRNUM;i++)
  29.     {   
  30.         pthread_join(tid[i],NULL);
  31.     }
  32.     pthread_mutex_destroy(&mut);    
  33.     return 0;
  34. }
  35.  
  36. void* thr_add(void*p)
  37. {
  38.     FILE*fp;
  39.     char line_buf[1024];
  40.     int len_size = 1024;
  41.  
  42.     pthread_mutex_lock(&mut);
  43.  
  44.  
  45.     fp = fopen(FILENAME,"r+");
  46.     fgets(line_buf,len_size,fp);
  47.     
  48.     fseek(fp,0,SEEK_SET);
  49.  
  50.     fprintf(fp,"%d n",atoi(line_buf)+1);
  51.     fclose(fp);
  52.     pthread_mutex_unlock(&mut);
  53.  
  54.     pthread_exit(NULL);
  55.  
  56.     return NULL;
  57.  }

abcd.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6.  
  7. #define FILENAME  "/tmp/out"
  8. #define THRNUM (4)
  9.  
  10. pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
  11.  
  12. void* thr_abcd(void*p);
  13.  
  14. int main()
  15. {
  16.     pthread_t tid[THRNUM];
  17.     int i,j,mark;
  18.    int err; 
  19.     for(i =0;i<THRNUM;i++)
  20.     {
  21.         err= pthread_create(tid+(i),NULL,thr_abcd,(void*)i);
  22.         if(err)
  23.         {
  24.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  25.         }
  26.     }
  27.     alarm(2);
  28.  
  29.     for(i=0;i<THRNUM;i++)
  30.     {   
  31.         pthread_join(tid[i],NULL);
  32.     }
  33.     pthread_mutex_destroy(&mut);    
  34.     return 0;
  35. }
  36.  
  37. void* thr_abcd(void*p)
  38. {
  39.     int c = 'a'+ (int)p;
  40.     while(1)
  41.     {
  42.         write(1,&c,1);
  43.     }
  44.     
  45.     pthread_exit(NULL);
  46.  
  47.     return NULL;
  48.  }

abcd.c
Usa la catena per bloccare e sbloccare.

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6.  
  7. #define FILENAME  "/tmp/out"
  8. #define THRNUM (4)
  9.  
  10. pthread_mutex_t mut[THRNUM];
  11.  
  12. void* thr_abcd(void*p);
  13.  
  14. int main()
  15. {
  16.     pthread_t tid[THRNUM];
  17.     int i,j,mark;
  18.    int err; 
  19.     for(i =0;i<THRNUM;i++)
  20.     {
  21.         pthread_mutex_init(mut+i,NULL); //初始化四个锁
  22.         pthread_mutex_lock(mut+i);
  23.  
  24.         err= pthread_create(tid+(i),NULL,thr_abcd,(void*)i);
  25.         if(err)
  26.         {
  27.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  28.         }
  29.     }
  30.     pthread_mutex_unlock(mut+0);
  31.     alarm(2);
  32.  
  33.     for(i=0;i<THRNUM;i++)
  34.     {   
  35.         pthread_join(tid[i],NULL);
  36.     }
  37.     pthread_mutex_destroy(&mut);    
  38.     return 0;
  39. }
  40. int next(int n)
  41. {
  42.     if(n +1 ==THRNUM)
  43.         return 0;
  44.     return n+1;
  45. }
  46. void* thr_abcd(void*p)
  47. {
  48.     int c = 'a'+ (int)p;
  49.     int n = (int)p;
  50.     while(1)
  51.     {
  52.         pthread_mutex_lock(mut+n);
  53.         write(1,&c,1);
  54.         pthread_mutex_unlock(mut+next(n) );
  55.     }
  56.     pthread_exit(NULL);
  57.  
  58.     return NULL;
  59.  }

L'algoritmo del pool implementa il calcolo dei numeri primi (metodo query)

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #define LEFT  30000000
  7. #define RIGHT 30000200
  8. #define THRNUM (RIGHT-LEFT+1)
  9.      
  10. void* thr_prime(void*p);
  11.  
  12. int main()
  13. {
  14.     pthread_t tid[THRNUM];
  15.     int i,j,mark;
  16.    int err; 
  17.     for(i =LEFT;i<=RIGHT;i++)
  18.     {
  19.         err= pthread_create(tid+(i-LEFT),NULL,thr_prime,(void *)i);
  20.         // err= pthread_create(tid+(i-LEFT),NULL,thr_prime,&i);
  21.         if(err)
  22.         {
  23.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  24.         }
  25.     }
  26.  
  27.     for(i=LEFT;i<=RIGHT;i++)
  28.     {
  29.         pthread_join(tid[i-LEFT],NULL);
  30.     }
  31.     
  32.     return 0;
  33. }
  34.  
  35. void* thr_prime(void*p)
  36. {
  37.     int i,j,mark;
  38.  
  39.     i = (int)p;
  40.     // i = *(int*)p;
  41.  
  42.     mark = 1;
  43.     for(j=2;j<i/2;j++)
  44.     {
  45.         if(i%j ==0)
  46.         {
  47.             mark = 0;
  48.             break;
  49.         }
  50.     }
  51.     if(mark)
  52.         printf("%d is a primer n",i);
  53.     pthread_exit(NULL);
  54.     return NULL;
  55.  }

variabile di condizione

Atto di notifica per la comunicazione.

int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *limita cond,
const pthread_condattr_t *limita attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_broadcast(pthread_cond_t *cond); //Sveglia tutti in attesa
int pthread_cond_signal(pthread_cond_t *cond);//Riattiva qualsiasi attesa
int pthread_cond_timedwait(pthread_cond_t *restrict cond, //attesa timeout
pthread_mutex_t *limita mutex,
const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond, //riferimento
pthread_mutex_t *limita mutex);

mytbf.c (metodo di notifica)

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <error.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9. #include <errno.h>
  10. #include <signal.h>
  11. #include <pthread.h>
  12.  
  13. #include "mytbf.h"
  14.  
  15. struct mytbf_st
  16. {
  17.     int cps;
  18.     int burst;
  19.     int token;
  20.     int pos;
  21. 	pthread_mutex_t mut;
  22.     pthread_cond_t cond;
  23.  
  24. };
  25. static pthread_mutex_t mut_job = PTHREAD_MUTEX_INITIALIZER;
  26. static pthread_t tid_alrm;
  27. pthread_once_t init_once = PTHREAD_ONCE_INIT;
  28.  
  29. static struct mytbf_st* job[MYTBF_MAX];
  30.  
  31. typedef void (*sighandler_t)(int);
  32.  
  33.  
  34. static int get_free_pos_unlocked(void)
  35. {
  36.     for(int i=0;i< MYTBF_MAX;i++)
  37.     {
  38.         if(job[i]==NULL)
  39.             return i;
  40.     }
  41.     return -1;
  42. }
  43.  
  44. static void*  thr_alrm(void*p)
  45. {
  46. 	while(1)
  47. 	{
  48. 		pthread_mutex_lock(&mut_job);
  49. 		for(int i=0;i<MYTBF_MAX;i++)
  50. 		{
  51. 			if(job[i] != NULL)
  52. 			{
  53. 				pthread_mutex_lock(&job[i]->mut);
  54. 				job[i]->token += job[i]->cps;
  55. 				if(job[i]->token >job[i]->burst )
  56. 				{
  57. 					job[i]->token = job[i]->burst;
  58. 				}
  59.                 pthread_cond_broadcast(&job[i]->cond);
  60. 				pthread_mutex_unlock(&job[i]->mut);
  61. 			}
  62. 		}
  63. 		pthread_mutex_unlock(&mut_job);
  64. 		sleep(1);
  65. 	}
  66.     return NULL;
  67. }
  68.  
  69. static void module_unload()
  70. {
  71. 	pthread_cancel(tid_alrm);
  72. 	pthread_join(tid_alrm,NULL);
  73. 	//只能一个人掉，二个人调用容易出差
  74.     for(int i=0;i<MYTBF_MAX;i++)
  75.     {
  76. 		if(job[i]!=NULL)
  77. 		{
  78. 			mytbf_destroy(job[i]);
  79. 		}
  80. 	}
  81. 	pthread_mutex_destroy(&mut_job);
  82.  
  83. }
  84.  
  85. static void module_load()
  86. {
  87.    int err;
  88.    err = pthread_create(&tid_alrm,NULL,thr_alrm,NULL);
  89. 	if(err)
  90. 	{
  91. 		fprintf(stderr,"create errorn");
  92. 		exit(1);
  93. 	}
  94.     atexit(module_unload);
  95. }
  96.  
  97. mytbf_t* mytbf_init(int cps ,int burst)  //C语言中，void*可以赋值给任何类型的指针，任何类型的指针也都可以赋值给void*
  98. {
  99.     struct mytbf_st*me;
  100.     int pos;
  101.     pthread_once(&init_once,module_load); //只初始化一次
  102. 	me = malloc(sizeof(*me));
  103.     if(me == NULL)
  104.         return NULL;
  105.  
  106.     me->cps = cps;
  107.     me->burst = burst;
  108.     me->token = 0;
  109.  
  110.     pthread_mutex_init(&me->mut,NULL);
  111.     pthread_cond_init(&me->cond,NULL);	
  112. 	pthread_mutex_lock(&mut_job);
  113.    
  114.    pos = get_free_pos_unlocked();
  115.     if(pos < 0)
  116. 	{
  117. 	
  118. 		pthread_mutex_unlock(&mut_job);
  119.         free(me);
  120. 		return NULL;
  121. 	}
  122.     me->pos = pos;
  123.     job[pos] = me;
  124.  
  125. 	pthread_mutex_unlock(&mut_job);
  126.     
  127. 	return me;
  128.  
  129. }
  130. int mytbf_fetchtoken(mytbf_t*ptr,int size)  //获取token
  131. {
  132.     if(size <= 0)
  133.         return -EINVAL;  //参数非法
  134.     struct mytbf_st*me = ptr;
  135. 	pthread_mutex_lock(&me->mut);
  136.     while(me->token <= 0 )  //token为空就等待
  137. 	{
  138.         pthread_cond_wait(&me->cond,&me->mut); //解锁等待，等待conad_broadcast和conad_signal的到来
  139.  
  140.     /*
  141. 		pthread_mutex_unlock(&me->mut);
  142. 		sched_yield();
  143. 		pthread_mutex_lock(&me->mut);
  144. 	*/
  145.     }
  146.  
  147.     
  148.     int n = (me->token>size?size:me->token);
  149.     me->token -= n;
  150.     pthread_mutex_unlock(&me->mut);
  151. 	return n;
  152. }
  153.  
  154. int mytbf_returntoken(mytbf_t*ptr,int size)  //返还token
  155. {
  156.     if(size<=0)
  157.         return -EINVAL;
  158.     struct mytbf_st*me = ptr;
  159.  
  160.     pthread_mutex_lock(&me->mut);
  161. 		
  162.     me->token+= size;
  163.     if(me->token > me->burst)
  164.         me->token  = me->burst;
  165.     pthread_cond_broadcast(&me->cond);
  166.     pthread_mutex_unlock(&me->mut);
  167.     return size;
  168. }
  169.  
  170. int mytbf_destroy(mytbf_t*ptr)
  171. {
  172.     struct mytbf_st *me;
  173.     me = ptr;
  174. 	pthread_mutex_lock(&mut_job);
  175.     job[me->pos] = NULL;
  176. 	pthread_mutex_unlock(&mut_job);
  177. 	pthread_mutex_destroy(&me->mut);
  178. 	pthread_cond_destroy(&me->cond);
  179. 	free(ptr);
  180.     return 0;
  181.     
  182. }

primer0_pool.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #include <sched.h>
  7.  
  8. #define LEFT  30000000
  9. #define RIGHT 30000200
  10. #define THRNUM (4)
  11.  
  12. static  int num = 0;
  13. static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
  14. static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  15.  
  16. void* thr_prime(void*p);
  17.  
  18. int main()
  19. {
  20.     pthread_t tid[THRNUM];
  21.     int i,j,mark;
  22.    int err; 
  23.     
  24.     for(i =0;i<=THRNUM;i++)
  25.     {
  26.         err= pthread_create(tid+(i),NULL,thr_prime,(void *)i);
  27.         if(err)
  28.         {
  29.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  30.         }
  31.     }
  32.     //下发任务
  33.     for(i=LEFT;i<RIGHT;i++)
  34.     {
  35.         pthread_mutex_lock(&mut);
  36.         while(num !=0)  //不是0就需要等待任务被取走
  37.         {
  38.             pthread_cond_wait(&cond,&mut);
  39.         }
  40.  
  41.         num = i; //下发任务
  42.         pthread_cond_signal(&cond); //下游叫醒任意一个
  43.         pthread_mutex_unlock(&mut);
  44.     }
  45.     pthread_mutex_lock(&mut);
  46.     while(num!= 0)
  47.     {
  48.         pthread_mutex_unlock(&mut);
  49.         sched_yield(); //出让调度器给别的线程
  50.     }
  51.     num = -1; //用于线程退出
  52.     pthread_cond_broadcast(&cond);
  53.  
  54.     pthread_mutex_unlock(&mut);
  55.  
  56.     for(i=0;i<=THRNUM;i++)
  57.     {
  58.         pthread_join(tid[i],NULL);
  59.     }
  60.     pthread_mutex_destroy(&mut);    
  61.     pthread_cond_destroy(&cond);    
  62.     return 0;
  63. }
  64.  
  65. void* thr_prime(void*p)
  66. {
  67.     int i,j,mark;
  68.    while(1)
  69.    {
  70.    pthread_mutex_lock(&mut);
  71.     while(num == 0)
  72.     {
  73.         pthread_cond_wait(&cond,&mut);
  74.     }
  75.     if(num == -1)
  76.     {
  77.         pthread_mutex_unlock(&mut); //走到这里必须要解锁。
  78.         break;
  79.     }
  80.     
  81.     i= num;    
  82.     num = 0;
  83.     pthread_cond_broadcast(&cond);
  84.  
  85.     pthread_mutex_unlock(&mut);
  86.  
  87.     mark = 1;
  88.     for(j=2;j<i/2;j++)
  89.     {
  90.         if(i%j ==0)
  91.         {
  92.             mark = 0;
  93.             break;
  94.         }
  95.     }
  96.     if(mark)
  97.         printf("[%d]%d is a primer n",(int)p,i);
  98.     }
  99.  
  100.     pthread_exit(NULL);
  101.     return NULL;
  102.  }

abcd_cond.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6.  
  7. #define FILENAME  "/tmp/out"
  8. #define THRNUM (4)
  9.  
  10. pthread_mutex_t mut  = PTHREAD_MUTEX_INITIALIZER;
  11. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  12. int num;
  13.  
  14. void* thr_abcd(void*p);
  15.  
  16. int main()
  17. {
  18.     pthread_t tid[THRNUM];
  19.     int i,j,mark;
  20.    int err; 
  21.     for(i =0;i<THRNUM;i++)
  22.     {
  23.  
  24.         err= pthread_create(tid+(i),NULL,thr_abcd,(void*)i);
  25.         if(err)
  26.         {
  27.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  28.         }
  29.     }
  30.     
  31.     alarm(2);
  32.  
  33.     for(i=0;i<THRNUM;i++)
  34.     {   
  35.         pthread_join(tid[i],NULL);
  36.     }
  37.     pthread_cond_destroy(&cond);
  38.     pthread_mutex_destroy(&mut);    
  39.     return 0;
  40. }
  41. int next(int n)
  42. {
  43.     if(n +1 ==THRNUM)
  44.         return 0;
  45.     return n+1;
  46. }
  47. void* thr_abcd(void*p)
  48. {
  49.     int c = 'a'+ (int)p;
  50.     int n = (int)p;
  51.     while(1)
  52.     {
  53.         pthread_mutex_lock(&mut);
  54.         while(num != n)
  55.         {
  56.             pthread_cond_wait(&cond,&mut);
  57.         }
  58.         write(1,&c,1);
  59.         num = next(num);
  60.         pthread_cond_broadcast(&cond);
  61.         pthread_mutex_unlock(&mut );
  62.     }
  63.     pthread_exit(NULL);
  64.  
  65.     return NULL;
  66.  }

segnale

Il mutex è di tipo bool e il semaforo è di tipo int Si decrementa quando viene utilizzato. Se non è sufficiente, attende.

ilmiosem.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include "mysem.h"
  7.  
  8. struct mysem_st
  9. {
  10. 	int value;
  11. 	pthread_mutex_t mut;
  12. 	pthread_cond_t cond;
  13.  
  14. };
  15.  
  16. mysem_t* mysem_init(int initval)
  17. {
  18. 	struct mysem_st*me;
  19. 	me = malloc(sizeof(*me));
  20. 	if(me==NULL)
  21. 		return NULL;
  22. 	me->value = initval;
  23. 	pthread_mutex_init(&me->mut,NULL);
  24. 	pthread_cond_init(&me->cond,NULL);
  25.  
  26. 	return me;
  27.  
  28. }
  29.  
  30. int mysem_add(mysem_t*ptr ,int n)
  31. {
  32. 	struct mysem_st*me = ptr;
  33.  
  34. 	pthread_mutex_lock(&me->mut);
  35.  
  36. 	me->value+= n;
  37. 	pthread_cond_broadcast(&me->cond);
  38. 	pthread_mutex_unlock(&me->mut);
  39.  
  40. 	return n;
  41. }
  42.  
  43. int mysem_sub(mysem_t*ptr ,int n )
  44. {
  45. 	struct mysem_st*me = ptr;
  46.  
  47. 	pthread_mutex_lock(&me->mut);
  48. 	while(me->value <n)
  49. 	{
  50. 		pthread_cond_wait(&me->cond,&me->mut);
  51. 	}
  52. 	me->value -=n;
  53.  
  54. 	pthread_mutex_unlock(&me->mut);
  55. 	return n;
  56. }
  57.  
  58. void  mysem_destroy(mysem_t*ptr)
  59. {
  60. 	struct mysem_st*me = ptr;
  61. 	pthread_mutex_destroy(&me->mut);
  62. 	pthread_cond_destroy(&me->cond);
  63. 	free(me);
  64. }
  65.  
  66.  
  67.

ilmiosem.h

  1. #ifndef MYSEM_H
  2. #define MYSEM_H
  3.  
  4. typedef void mysem_t;
  5.  
  6. mysem_t* mysem_init(int initval);
  7.  
  8. int mysem_add(mysem_t*,int);
  9.  
  10. int mysem_sub(mysem_t*,int);
  11.  
  12. void mysem_destroy(mysem_t*);
  13.  
  14.  
  15.  
  16. #endif

principale.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #include "mysem.h"
  7.  
  8. #define LEFT  30000000
  9. #define RIGHT 30000200
  10. #define THRNUM (RIGHT-LEFT+1)
  11.  
  12. #define N 4
  13. static mysem_t* sem;
  14.  
  15. void* thr_prime(void*p);
  16.  
  17. int main()
  18. {
  19.     pthread_t tid[THRNUM];
  20.     int i,j,mark;
  21.     int err; 
  22.     
  23.     sem = mysem_init(N);
  24.     if(sem ==NULL)
  25.     {
  26.         fprintf(stderr,"mysem_init n");
  27.         exit(1);
  28.     }
  29.  
  30.     for(i =LEFT;i<=RIGHT;i++)
  31.     {
  32.         mysem_sub(sem,1);
  33.  
  34.         err= pthread_create(tid+(i-LEFT),NULL,thr_prime,(void *)i);
  35.         if(err)
  36.         {
  37.             fprintf(stderr,"pthread_create():%sn",strerror(err));
  38.         }
  39.     }
  40.  
  41.     for(i=LEFT;i<=RIGHT;i++)
  42.     {
  43.         pthread_join(tid[i-LEFT],NULL);
  44.     }
  45.  
  46.     mysem_destroy(sem);   
  47.     
  48.     return 0;
  49. }
  50.  
  51. void* thr_prime(void*p)
  52. {
  53.     int i,j,mark;
  54.  
  55.     i = (int)p;
  56.     // i = *(int*)p;
  57.  
  58.     mark = 1;
  59.     for(j=2;j<i/2;j++)
  60.     {
  61.         if(i%j ==0)
  62.         {
  63.             mark = 0;
  64.             break;
  65.         }
  66.     }
  67.     if(mark)
  68.         printf("%d is a primer n",i);
  69.  
  70.     sleep(5); //ps ax -L 可以观察到对线程进行了限制，只创建了四个线程
  71.  
  72.     mysem_add(sem,1);
  73.     pthread_exit(NULL);
  74.  
  75.     return NULL;
  76.  }

file di creazione

  1. all:mysem
  2. CFLAGS+=-g -Wall -pthread
  3. LDFLAGS+= -pthread
  4.  
  5. mysem:main.o mysem.o
  6. 	gcc $^ $(CFLAGS)	$(LDFLAGS) -o $@ 
  7.  
  8. clean:
  9. 	rm -rf *.o mysem

blocco lettura-scrittura

Utilizzo completo di mutex e semafori. Diviso in blocco di lettura (semaforo) e blocco di scrittura (mutex). In generale, dovrebbe essere fissato un limite massimo per la lettura e la scrittura.

È necessario evitare che gli scrittori muoiano di fame.

4. Attributi relativi al thread

Il secondo parametro di pthread_create è l'attributo del thread.

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);

Il numero massimo di thread creati dal programma di test. ()

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <pthread.h>
  4.  
  5. void* func(void)
  6. {
  7.     int i;
  8.  
  9. //    printf("%pn",&i);
  10.     pthread_exit(NULL);
  11.     return NULL;
  12. }
  13.  
  14. int main()
  15. {
  16.     int err;
  17.     pthread_t tid;
  18.     pthread_attr_t attr;
  19.     pthread_attr_init(&attr);
  20.     pthread_attr_setstacksize(&attr,1024*1024); //1mb
  21.  
  22.     int i = 0;
  23.     for(;;i++)
  24.     {
  25.         err = pthread_create(&tid,&attr,func,NULL);
  26.         if(err)
  27.         {
  28.             fprintf(stderr,"create errn");
  29.             break;
  30.         }
  31.     }
  32.     printf("max = %d n",i);
  33.     pthread_attr_destroy(&attr);
  34.     return 0;
  35. }

Proprietà di sincronizzazione dei thread

Proprietà del mutex:

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
Fare riferimento a pthread_mutexattr_destroy().
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, //funziona tra processi
int *pshared);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
int condiviso);

//Crea un processo figlio che possa condividere l'array dei descrittori di file. Puoi anche scegliere di non condividerlo. Non c'è distinzione tra processi e thread sotto Linux
int clone(int (*fn)(void *), void *stack, int flag, void *arg, ...
/* pid_t *id_genitore, void *tls, pid_t *tid_figlio */ );
int pthread_mutexattr_gettype(const pthread_mutexattr_t *limita attr,
int *limita tipo);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int tipo);

Proprietà delle variabili condizionali:
int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);
Proprietà del blocco di lettura-scrittura:

5. Rientro

Una funzione rientrante è semplicemente una funzione che può essere interrotta, ovvero è possibile interrompere questa funzione in qualsiasi momento durante la sua esecuzione e trasferirla alla pianificazione del sistema operativo per eseguire un'altra parte di codice senza errori quando si restituisce il controllo le funzioni utilizzano alcune risorse di sistema, come aree variabili globali, tabelle vettoriali di interruzione, ecc., quindi se vengono interrotte, potrebbero verificarsi problemi. Tali funzioni non possono essere eseguite in un ambiente multi-tasking.

IO in multithreading. La funzione sbloccata termina con (funzione non rientrante, la concorrenza multi-thread non è supportata). man putc_unlocked, visualizza le operazioni di I/O non supportate.

Fili e segnali

int pthread_sigmask(int come, const sigset_t *set, sigset_t *oldset);
int sigwait(const sigset_t *set, int *sig);
int pthread_kill(pthread_t thread, int sig);

standard del thread OpenMP

Fare riferimento al sito Web ufficiale: www.OpenMp.org

I tag di sintassi Openmp sono supportati dopo gcc4.0.Quante simultaneità si possono ottenere con poche CPU?

Ciao C

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int main()
  5. {
  6. #pragma omp parallel  //实现并发
  7. {
  8.     puts("Hello ");
  9.     puts(" World");
  10. }
  11.     return 0;
  12. }

file di creazione

CFLAGS += -Wall -fopenmp

Compila make hello ed eseguilo.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <omp.h>
  4.  
  5. int main()
  6. {
  7. #pragma omp parallel  sections
  8. {
  9. #pragma omp section
  10.     printf("[%d:]Hello n",omp_get_thread_num() );
  11. #pragma omp section
  12.     printf("[%d:]World n",omp_get_thread_num() );
  13. }
  14.     return 0;
  15. }

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta