Technologieaustausch

C-Sprache: Erweiterte Parallelitätsoperationen (Threads)

2024-07-12

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

1. Das Konzept des Threads

Thread: Eine Entität in einem Prozess und die Grundeinheit der CPU-Planung und -Verteilung. Der Thread selbst besitzt grundsätzlich keine Systemressourcen, sondern nur einige Ressourcen, die für die Ausführung unerlässlich sind (z. B. einen Programmzähler, eine Reihe von Registern und einen Stapel), aber er kann alle Ressourcen, die der Prozess besitzt, mit anderen Threads teilen die zum selben Prozess gehören. Ein Thread kann einen anderen Thread erstellen und zerstören; mehrere Threads im selben Prozess können gleichzeitig ausgeführt werden. Threads zeigen während des Betriebs intermittierendes Verhalten. (Das Obige stammt aus „Computer Level 4 Tutorial – Betriebssystemprinzipien“)

Wenn es um Threads geht, muss über die Definition von Prozessen gesprochen werden: Ein Prozess ist ein Programm mit bestimmten unabhängigen Funktionen. Ein Prozess ist eine unabhängige Einheit für die Ressourcenzuweisung und -planung im System. (Das Obige stammt aus „Computer Level 4 Tutorial – Betriebssystemprinzipien“)

Die Definition von Prozess ist etwas kompliziert. Schauen wir uns an, woraus ein Prozess besteht: Programm, Daten und Prozesssteuerungsblock. Unter diesen entspricht das Programm „einem Programm mit bestimmten unabhängigen Funktionen“ in der Prozessdefinition. Zusätzlich zum Programm selbst benötigt der Prozess jedoch auch Daten (die als Ressourcen verstanden werden können) und Prozesssteuerungsblöcke. Daten- und Prozesssteuerungsblöcke sind wesentliche Ressourcen, wenn ein Programm ausgeführt wird. Das Programm ist auf diese Ressourcen angewiesen, um entsprechende Aktivitäten auszuführen, was wir als „Prozess“ bezeichnen.

Zwei grundlegende Eigenschaften von Prozessen:

Ein Prozess ist eine unabhängige Einheit, die Ressourcen besitzen kann;
Ein Prozess ist eine Grundeinheit, die unabhängig geplant und versendet werden kann.
Als Threads zum ersten Mal eingerichtet wurden, dienten sie dazu, die beiden oben genannten Attribute des Prozesses zu trennen. Threads bilden die „Grundeinheit der CPU-Planung und -Verteilung“. Auf diese Weise kann es viele Threads in einem Prozess geben, und das Betriebssystem kann planen und Threads besser versenden Es kann die parallele Ausführung von Prozessen gleichzeitig realisieren, Threads unter demselben Prozess können alle Ressourcen des Prozesses gemeinsam nutzen, was den Zugriff auf Prozessressourcen durch verschiedene Threads unter demselben Prozess erfüllen kann. Durch die Entstehung von Threads werden die beiden Attribute des Prozesses geschickt getrennt, sodass der Prozess die Anforderungen der parallelen Ausführung besser erfüllen kann.

Ein Thread ist eine laufende Funktion. POSIX-Threads sind eine Reihe von Standards, keine Reihe von Implementierungen. Es gibt andere Standards wie zum Beispiel: OpenMP-Threads.
Thread-ID: pthread_t (Ich kenne den spezifischen Inhalt nicht, jedes Unternehmen implementiert ihn anders, unter Linux ist er int)
Der Befehl px axm erkennt Prozesse und Threads – also Threads unter einem Prozess. px ax -L, um Lightweight-Threads anzuzeigen.

int pthread_equal(pthread_t t1, pthread_t t2); Vergleichen Sie die ID-Nummern zweier Threads. Wenn sie gleich sind, wird ein Wert ungleich Null zurückgegeben; wenn sie unterschiedlich sind, wird 0 zurückgegeben.
pthread_t pthread_self(void); Holen Sie sich die Thread-ID des aktuellen Threads

2. Erstellung von Threads

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
Die Thread-Planung hängt von der Strategie des Planers ab.

create1.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. }

Thread-Abschluss

1. Der Thread kehrt von der Startroutine zurück und der Rückgabewert ist der Exit-Code des Threads.
2. Threads können von anderen Threads im selben Prozess abgebrochen werden.
3. Der Thread ruft die Funktion pthread_exit() auf. void pthread_exit(void *retval);

int pthread_join(pthread_t thread, void **retval); Es entspricht dem Warten des Prozesses und wird zum Sammeln von Leichen verwendet.

  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. }

Stapelbereinigung

pthread_cleanup_push(); //Entspricht atexit
pthread_cleanup_pop(); //Entspricht dem aktiven Abrufen von Daten.

void pthread_cleanup_push(void (*routine)(void *) ist die Implementierung des Makros gcc -E zum Anzeigen der Vorverarbeitung
ungültig *arg);
void pthread_cleanup_pop(intexe); //Wählen Sie, ob aufgerufen werden soll.Muss paarweise erscheinen, implementiert mit Makros

Aufräumen.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. }

Abbruchoptionen für Threads

Wenn der laufende Thread die Leiche einsammeln möchte, muss er zuerst abbrechen (pthread_cancel) und dann die Leiche einsammeln (pthread_join).

Thread-Abbruch: int pthread_cancel(pthread_t thread);
Die Stornierung hat zwei Status: erlaubt und nicht erlaubt.
Stornierung nicht zulässig: Die Codeausführung wird unbeeinträchtigt fortgesetzt.
Der zulässige Abbruch ist unterteilt in: asynchronen Abbruch und verzögerten Abbruch (Standard) -&gt; verzögerte Antwort bis zum Abbruchpunkt.
Abbruchpunkt: Die von Posix definierten Abbruchpunkte sind Systemaufrufe, die zu einer Überlastung führen können.
pthread_setcancelstate: Der Abbruchstatus kann festgelegt werden.
pthread_setcanceltype: Sie können die Abbruchmethode festlegen.
pthread_testcancel: Die Funktion macht nichts, bricht nur den Punkt ab.

Thread-Ablösung: int pthread_detach(pthread_t thread);

Dynamische Modul-Einzelinitialisierungsfunktion: int pthread_once(pthread_once_t *once_control,
void (*init_routine)(void));
pthread_once_t einmal_Steuerung = PTHREAD_ONCE_INIT;
 

Beispiel 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.  }

Wenn der obige Code ausgeführt wird, wird es Konkurrenz geben. Da Parameter per Adresse übergeben werden, müssen die Daten per * abgerufen werden und es gibt keine Garantie dafür, ob der vorherige Thread die Operation ausgeführt hat. Die einfachste Methode ist die Wertübergabe.

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.  }
Beispiel 2

add.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.  }

Konkurrenz und Konflikte können auftreten, wenn zwanzig Threads gleichzeitig Daten in einer Datei lesen und schreiben. Bevor ein Thread einschreibt, liest ein anderer Thread die letzten Daten.

mytbf.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. Thread-Synchronisation

Mutex

Es entspricht einem Schloss, das entriegelt werden muss, bevor es betätigt werden kann. (Abfragemethode)
Wenn man pthread_mutex_init einen Fehler meldet, installieren Sie bitte die Abhängigkeiten:
sudo apt-get installiere manpages-posix manpages-posix-dev

int pthread_mutex_destroy(pthread_mutex_t *mutex); //Zerstöre die Sperre
int pthread_mutex_init(pthread_mutex_t *mutex einschränken,
const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; statische Initialisierung

int pthread_mutex_lock(pthread_mutex_t *mutex); // kein Thread
int pthread_mutex_trylock(pthread_mutex_t *mutex);//Versuchen Sie zu sperren, wenn nicht, fahren Sie mit der Ausführung fort
int pthread_mutex_unlock(pthread_mutex_t *mutex);//Entsperren

add.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
Verwenden Sie die Kette zum Ver- und Entriegeln.

  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.  }

Der Pool-Algorithmus implementiert die Primzahlberechnung (Abfragemethode).

  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.  }

Bedingungsvariable

Mitteilungsgesetz für Kommunikation.

: In diesem Artikel wird pthread_cond_destroy.exe beschrieben.
int pthread_cond_init(pthread_cond_t *Bedingung einschränken,
const pthread_condattr_t *attr einschränken);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_broadcast(pthread_cond_t *cond); //Weckt alle Wartenden auf
int pthread_cond_signal(pthread_cond_t *cond);//Wende alle Wartezeiten auf
int pthread_cond_timedwait(pthread_cond_t *restrict cond, //timeout wait
pthread_mutex_t *Mutex einschränken,
const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond, //Bedingung einschränken
pthread_mutex_t *Mutex einschränken);

mytbf.c (Benachrichtigungsmethode)

  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.  }

Signal

Der Mutex ist vom Typ bool und der Semaphor ist vom Typ int. Er dekrementiert sich selbst, wenn er nicht ausreicht, wartet er.

mysem.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.

mysem.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

Haupt 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.  }

Make-Datei

  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

Lese-/Schreibsperre

Umfassender Einsatz von Mutexes und Semaphoren. Unterteilt in Lesesperre (Semaphor) und Schreibsperre (Mutex). Generell sollte eine Obergrenze für das Lesen und Schreiben festgelegt werden.

Es muss verhindert werden, dass Schriftsteller verhungern.

4. Threadbezogene Attribute

Der zweite Parameter von pthread_create ist das Attribut des Threads.

pthread_attr_init(pthread_attr_t *attr);
: In diesem Artikel wird beschrieben, wie Sie pthread_attr_destroy mithilfe von pthread_attr_t zerstören.

Die maximale Anzahl der vom Testprogramm erstellten Threads. ()

  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. }

Eigenschaften der Thread-Synchronisierung

Mutex-Eigenschaften:

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
Siehe pthread_mutexattr_destroy().
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, //funktioniert prozessübergreifend
}
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
}

//Erstellen Sie einen untergeordneten Prozess, der das Dateideskriptor-Array gemeinsam nutzen kann. Sie können es auch nicht freigeben. Unter Linux gibt es keine Unterscheidung zwischen Prozessen und Threads
int-Klon(int (*fn)(void *), void *stack, int-Flags, void *arg, …
/* pid_t *übergeordnete_tid, void *tls, pid_t *untergeordnete_tid */ );
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr einschränken,
int *Typ einschränken);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int Typ);

Eigenschaften der Bedingungsvariablen:
int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);
Eigenschaften der Lese-/Schreibsperre:

5. Wiedereintritt

Eine wiedereintrittsfähige Funktion ist einfach eine Funktion, die unterbrochen werden kann. Das heißt, Sie können diese Funktion jederzeit während ihrer Ausführung unterbrechen und an die Betriebssystemplanung übergeben, um bei der Rückgabe der Kontrolle einen anderen Code auszuführen Funktionen nutzen einige Systemressourcen, z. B. globale Variablenbereiche, Interrupt-Vektortabellen usw. Wenn sie unterbrochen werden, können solche Funktionen in einer Multitasking-Umgebung nicht ausgeführt werden.

IO im Multithreading. Die entsperrte Funktion endet mit (nicht wiedereintrittsfähige Funktion, Multithread-Parallelität wird nicht unterstützt). man putc_unlocked, nicht unterstützte E/A-Vorgänge anzeigen.

Threads und Signale

int pthread_sigmask(int wie, const sigset_t *set, sigset_t *oldset);
sigwait(const sigset_t *set, int *sig);
int pthread_kill(pthread_t-Thread, int sig);

OpenMP-Thread-Standard

Weitere Informationen finden Sie auf der offiziellen Website: www.OpenMp.org

Openmp-Syntax-Tags werden nach gcc4.0 unterstützt.Wie viele Parallelitäten können mit nur wenigen CPUs erreicht werden?

Hallo 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. }

Make-Datei

CFLAGS += -Wall -fopenmp

Kompilieren Sie „make hello“ und führen Sie es aus.

  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. }

Persönliches Profil

Er widmet sich seit mehr als 30 Jahren der Technologieforschung und beherrscht verschiedene Sprachen wie Java, Linux, Javascript, PHP, CSS usw. Er hat viele Beiträge im Open-Source-Bereich geleistet, Entwicklerdokumentationsstation, um einige Themen in der Technologieentwicklung als zukünftige Referenz zu teilen

meine Kontaktdaten

Post