Κοινή χρήση τεχνολογίας

Γλώσσα C: προηγμένες λειτουργίες συγχρονισμού (νήματα)

2024-07-12

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

1. Η έννοια του νήματος

Thread: Μια οντότητα σε μια διαδικασία και η βασική μονάδα προγραμματισμού και αποστολής CPU. Το ίδιο το νήμα βασικά δεν κατέχει πόρους συστήματος, μόνο μερικούς πόρους που είναι απαραίτητοι για την εκτέλεση (όπως ένας μετρητής προγράμματος, ένα σύνολο καταχωρητών και μια στοίβα), αλλά μπορεί να μοιραστεί όλους τους πόρους που ανήκουν στη διαδικασία με άλλα νήματα που ανήκουν στην ίδια διαδικασία. Ένα νήμα μπορεί να δημιουργήσει και να καταστρέψει ένα άλλο νήμα στην ίδια διαδικασία μπορεί να εκτελεστεί ταυτόχρονα. Τα νήματα παρουσιάζουν διακοπτόμενη συμπεριφορά κατά τη λειτουργία. (Τα παραπάνω είναι από το "Εκμάθηση Επιπέδου 4 Υπολογιστή - Αρχές Λειτουργικού Συστήματος")

Όταν πρόκειται για νήματα, είναι απαραίτητο να μιλήσουμε για τον ορισμό της διαδικασίας: μια διεργασία είναι ένα πρόγραμμα με ορισμένες ανεξάρτητες λειτουργίες. (Τα παραπάνω είναι από το "Εκμάθηση Επιπέδου 4 Υπολογιστή - Αρχές Λειτουργικού Συστήματος")

Ο ορισμός της διαδικασίας είναι λίγο περίπλοκος Ας δούμε τι αποτελείται από μια διεργασία: πρόγραμμα, μπλοκ ελέγχου δεδομένων και διεργασίας. Μεταξύ αυτών, το πρόγραμμα αντιστοιχεί σε "ένα πρόγραμμα με ορισμένες ανεξάρτητες λειτουργίες" στον ορισμό της διαδικασίας. Ωστόσο, εκτός από το ίδιο το πρόγραμμα, η διαδικασία χρειάζεται επίσης δεδομένα (που μπορούν να γίνουν κατανοητά ως πόροι) και μπλοκ ελέγχου διεργασιών. Τα μπλοκ ελέγχου δεδομένων και διεργασιών είναι βασικοί πόροι όταν εκτελείται ένα πρόγραμμα Το πρόγραμμα βασίζεται σε αυτούς τους πόρους για την εκτέλεση αντίστοιχων δραστηριοτήτων, κάτι που ονομάζουμε "διαδικασία".

Δύο βασικές ιδιότητες των διεργασιών:

Μια διαδικασία είναι μια ανεξάρτητη μονάδα που μπορεί να κατέχει πόρους.
Μια διαδικασία είναι μια βασική μονάδα που μπορεί να προγραμματιστεί και να αποσταλεί ανεξάρτητα.
Όταν δημιουργήθηκαν για πρώτη φορά τα νήματα, ήταν να διαχωριστούν τα παραπάνω δύο χαρακτηριστικά της διεργασίας. Τα νήματα αποτελούν τη «βασική μονάδα προγραμματισμού και αποστολής της CPU». Μπορεί να πραγματοποιήσει παράλληλη εκτέλεση διεργασιών την ίδια στιγμή, τα νήματα κάτω από την ίδια διεργασία μπορούν να μοιράζονται όλους τους πόρους της διαδικασίας, οι οποίοι μπορούν να ικανοποιήσουν την πρόσβαση των πόρων διεργασίας από διαφορετικά νήματα κάτω από την ίδια διαδικασία. Η εμφάνιση νημάτων διαχωρίζει έξυπνα τα δύο χαρακτηριστικά της διαδικασίας, επιτρέποντας στη διαδικασία να χειριστεί καλύτερα τις ανάγκες παράλληλης εκτέλεσης.

Ένα νήμα είναι μια λειτουργία που εκτελείται. Τα νήματα POSIX είναι ένα σύνολο προτύπων, όχι ένα σύνολο υλοποιήσεων. Υπάρχουν και άλλα πρότυπα όπως: νήματα openmp.
Αναγνωριστικό νήματος: pthread_t (δεν ξέρω το συγκεκριμένο περιεχόμενο, κάθε εταιρεία το εφαρμόζει διαφορετικά, στο Linux είναι int)
Η εντολή px axm βλέπει διεργασίες και νήματα - που αντιπροσωπεύουν τα νήματα σε μια διεργασία. px ax -L για προβολή ελαφρών νημάτων.

int pthread_equal(pthread_t t1, pthread_t t2) Συγκρίνετε τους αριθμούς ID δύο νημάτων. Εάν είναι ίδιες, επιστρέφεται το μηδενικό εάν είναι διαφορετικά, επιστρέφεται το 0.
pthread_t pthread_self(void) Λάβετε το αναγνωριστικό νήματος του τρέχοντος νήματος

2. Δημιουργία νημάτων

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
Ο προγραμματισμός νημάτων εξαρτάται από τη στρατηγική του προγραμματιστή.

δημιουργία1.γ

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

Τερματισμός νήματος

1. Το νήμα επιστρέφει από τη ρουτίνα εκκίνησης και η τιμή επιστροφής είναι ο κωδικός εξόδου του νήματος.
2. Τα νήματα μπορούν να ακυρωθούν από άλλα νήματα στην ίδια διαδικασία.
3. Το νήμα καλεί τη συνάρτηση pthread_exit(). void pthread_exit(void *retval);

int pthread_join(pthread_t νήμα, void **retval Είναι ισοδύναμο με την αναμονή της διαδικασίας και χρησιμοποιείται για τη συλλογή πτωμάτων).

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

καθαρισμός στοίβας

pthread_cleanup_push( //Iquivalent to atexit
pthread_cleanup_pop() //Ισοδύναμο με ενεργή ανάκτηση δεδομένων.

void pthread_cleanup_push(void (*routine)(void *), είναι η υλοποίηση της μακροεντολής, gcc -E για προβολή προεπεξεργασίας
void *arg);
void pthread_cleanup_pop(int execute //Επιλέξτε εάν θέλετε να καλέσετε).Πρέπει να εμφανίζεται σε ζεύγη, υλοποιείται με μακροεντολές

εκκαθάριση.γ

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

Ακύρωση επιλογών για νήματα

Εάν το τρέχον νήμα θέλει να συλλέξει το πτώμα, πρέπει πρώτα να ακυρώσει (pthread_cancel) και μετά να συλλέξει το πτώμα (pthread_join).

Ακύρωση νήματος: int pthread_cancel(pthread_t νήμα);
Η ακύρωση έχει δύο καταστάσεις: επιτρέπεται και δεν επιτρέπεται.
Δεν επιτρέπεται η ακύρωση: η εκτέλεση κώδικα συνεχίζεται ανεπηρέαστη.
Η επιτρεπόμενη ακύρωση χωρίζεται σε: ασύγχρονη ακύρωση και καθυστερημένη ακύρωση (προεπιλογή) -&gt; καθυστερημένη απόκριση μέχρι το σημείο ακύρωσης.
Σημείο ακύρωσης: Τα σημεία ακύρωσης που ορίζονται από το Posix είναι κλήσεις συστήματος που μπορεί να προκαλέσουν συμφόρηση.
pthread_setcancelstate: Μπορεί να οριστεί η κατάσταση ακύρωσης.
pthread_setcanceltype: Μπορείτε να ορίσετε τη μέθοδο ακύρωσης.
pthread_testcancel: Η συνάρτηση δεν κάνει τίποτα, απλώς ακυρώνει το σημείο.

Αποκόλληση νήματος: int pthread_detach(pthread_t νήμα);

Συνάρτηση μονής προετοιμασίας δυναμικής μονάδας: int pthread_once(pthread_once_t *once_control,
void (*init_routine)(void));
pthread_once_t Once_control = PTHREAD_ONCE_INIT;
 

Παράδειγμα 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.  }

Θα υπάρχει ανταγωνισμός όταν εκτελεστεί ο παραπάνω κώδικας. Επειδή οι παράμετροι μεταβιβάζονται από τη διεύθυνση, τα δεδομένα πρέπει να ανακτηθούν από το * και δεν υπάρχει εγγύηση εάν το προηγούμενο νήμα έχει εκτελέσει τη λειτουργία.

αστάρι0.γ

  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.  }
Παράδειγμα 2

προσθήκη.γ

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

Ο ανταγωνισμός και οι συγκρούσεις μπορεί να προκύψουν όταν είκοσι νήματα διαβάζουν και γράφουν δεδομένα σε ένα αρχείο ταυτόχρονα. Πριν γράψει ένα νήμα, ένα άλλο νήμα διαβάζει τα τελευταία δεδομένα.

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. Συγχρονισμός νημάτων

mutex

Είναι ισοδύναμο με κλειδαριά και πρέπει να ξεκλειδωθεί για να μπορέσει να λειτουργήσει. (μέθοδος ερωτήματος)
Εάν ο man pthread_mutex_init αναφέρει ένα σφάλμα, εγκαταστήστε τις εξαρτήσεις:
sudo apt-get install manpages-posix manpages-posix-dev

int pthread_mutex_destroy(pthread_mutex_t *mutex)
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

int pthread_mutex_lock(pthread_mutex_t *mutex); //加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);//Δοκιμάστε να κλειδώσετε, αν όχι, συνεχίστε την εκτέλεση
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁

προσθήκη.γ

  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
Χρησιμοποιήστε την αλυσίδα για να κλειδώσετε και να ξεκλειδώσετε.

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

Ο αλγόριθμος συγκέντρωσης υλοποιεί τον υπολογισμό του πρώτου αριθμού (μέθοδος ερωτήματος)

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

μεταβλητή συνθήκης

Νόμος ειδοποίησης για επικοινωνία.

int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);//Ξυπνήστε οποιαδήποτε αναμονή
int pthread_cond_timedwait(pthread_cond_t *restrict cond, //timeout wait
pthread_mutex_t *περιορισμός mutex,
const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond, //死等
pthread_mutex_t *restrict mutex);

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

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

σήμα

Το mutex είναι τύπου bool και ο σηματοφόρος είναι τύπου int Μειώνεται όταν χρησιμοποιείται.

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

κύρια.γ

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

makefile

  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

κλειδαριά ανάγνωσης-εγγραφής

Ολοκληρωμένη χρήση mutexes και σηματοφόρων. Χωρίζεται σε κλειδαριά ανάγνωσης (σηματοφορέας) και κλειδαριά εγγραφής (mutex). Γενικά, θα πρέπει να τεθεί ένα ανώτατο όριο για ανάγνωση και γραφή.

Είναι απαραίτητο να αποτρέψουμε τους συγγραφείς να πεθάνουν από την πείνα.

4. Χαρακτηριστικά που σχετίζονται με νήματα

Η δεύτερη παράμετρος του pthread_create είναι το χαρακτηριστικό του νήματος.

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

Ο μέγιστος αριθμός νημάτων που δημιουργήθηκαν από το δοκιμαστικό πρόγραμμα. ()

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

Ιδιότητες συγχρονισμού νημάτων

Ιδιότητες Mutex:

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
Ανατρέξτε στο pthread_mutexattr_destroy().
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, //λειτουργεί σε όλες τις διεργασίες
int *pshared);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
int pshared);

//Δημιουργία θυγατρικής διαδικασίας που μπορεί να μοιράζεται τον πίνακα περιγραφής αρχείων Μπορείτε επίσης να επιλέξετε να μην τον κοινοποιήσετε. Δεν υπάρχει διάκριση μεταξύ διεργασιών και νημάτων στο Linux
int clone(int (*fn)(void *), void *stack, int flags, void *arg, ...
/* pid_t *parent_tid, void *tls, pid_t *child_tid */ );
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr,
int *restrict type);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, τύπος int);

Ιδιότητες μεταβλητής συνθήκης:
int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);
Ιδιότητες κλειδώματος ανάγνωσης-εγγραφής:

5. Επανεισαγωγή

Μια συνάρτηση επανεισαγωγής είναι απλώς μια συνάρτηση που μπορεί να διακοπεί, δηλαδή, μπορείτε να διακόψετε αυτή τη λειτουργία ανά πάσα στιγμή κατά την εκτέλεσή της και να τη μεταφέρετε στον προγραμματισμό του λειτουργικού συστήματος χωρίς σφάλματα κατά την επιστροφή του στοιχείου ελέγχου Οι συναρτήσεις χρησιμοποιούν ορισμένους πόρους του συστήματος, όπως καθολικές μεταβλητές περιοχές, πίνακες διανυσμάτων διακοπής, κ.λπ., επομένως, εάν διακοπούν, ενδέχεται να προκύψουν προβλήματα τέτοιες συναρτήσεις σε περιβάλλον πολλαπλών εργασιών.

IO σε multithreading. Η ξεκλείδωτη συνάρτηση τελειώνει με (συνάρτηση χωρίς επανεισαγωγή, η ταυτόχρονη πολλαπλών νημάτων δεν υποστηρίζεται). man putc_unlocked, προβολή μη υποστηριζόμενων λειτουργιών IO.

Νήματα και σήματα

int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset);
int sigwait(const sigset_t *set, int *sig);
int pthread_kill(pthread_t νήμα, int sig);

πρότυπο νήμα openmp

Ανατρέξτε στον επίσημο ιστότοπο: www.OpenMp.org

Οι συντακτικές ετικέτες Openmp υποστηρίζονται μετά το gcc4.0.Πόσες ταυτότητες μπορούν να επιτευχθούν με λίγες μόνο CPU;

γεια.γ

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

makefile

CFLAGS += -Wall -fopenmp

Compile make hello και εκτελέστε το.

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

Προσωπικό προφίλ

Έχει αφοσιωθεί στην έρευνα της τεχνολογίας για περισσότερα από 30 χρόνια και είναι ικανός σε διάφορες γλώσσες όπως java, linux, javascript, php, css κ.λπ. Έχει κάνει πολλές συνεισφορές στον τομέα του ανοιχτού κώδικα σταθμός τεκμηρίωσης προγραμματιστή για να μοιραστείτε ορισμένα ζητήματα στην ανάπτυξη τεχνολογίας για μελλοντική αναφορά

τα στοιχεία επικοινωνίας μου

Ταχυδρομείο