प्रौद्योगिकी साझेदारी

ग भाषा: उन्नतसमवर्तीक्रियाः (धागाः)

2024-07-12

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

1. सूत्रस्य अवधारणा

थ्रेड् : प्रक्रियायां एकः सत्ता तथा च CPU समयनिर्धारणस्य प्रेषणस्य च मूलभूतं एककं । सूत्रस्य एव मूलतः प्रणालीसंसाधनानाम् स्वामित्वं नास्ति, केवलं कतिपयानि संसाधनानि सन्ति ये चालनार्थं अत्यावश्यकाः सन्ति (यथा प्रोग्रामगणकः, रजिस्टर्-समूहः, स्तम्भः च), परन्तु सः प्रक्रियायाः स्वामित्वं प्राप्तान् सर्वान् संसाधनान् अन्यैः थ्रेड्-सहितं साझां कर्तुं शक्नोति ये समानप्रक्रियायाः सन्ति। एकः सूत्रः अन्यं सूत्रं निर्मातुम्, नाशयितुं च शक्नोति, एकस्मिन् एव प्रक्रियायां बहुविधं सूत्रं युगपत् निष्पादयितुं शक्नोति; धागाः कार्यकाले व्यत्यस्तव्यवहारं दर्शयन्ति । (उपरोक्तं "कम्प्यूटर लेवल ४ ट्युटोरियल् - ऑपरेटिंग् सिस्टम् सिद्धान्ताः" इत्यस्मात् अस्ति)

यदा थ्रेड्स इत्यस्य विषयः आगच्छति तदा प्रक्रियायाः परिभाषायाः विषये वक्तुं आवश्यकम् अस्ति : प्रक्रिया एकः कार्यक्रमः अस्ति यस्य कतिपयानि स्वतन्त्राणि कार्याणि सन्ति प्रक्रिया प्रणाल्यां संसाधनविनियोगाय, समयनिर्धारणाय च स्वतन्त्रः एककः भवति (उपरोक्तं "कम्प्यूटर लेवल 4 ट्युटोरियल् - ऑपरेटिंग् सिस्टम् सिद्धान्ताः" इत्यस्मात् अस्ति)

प्रक्रियायाः परिभाषा किञ्चित् जटिला भवति पश्यामः यत् प्रक्रियायां किं भवति: कार्यक्रमः, आँकडा, प्रक्रियानियन्त्रणखण्डः च । तेषु कार्यक्रमः प्रक्रियापरिभाषायां "कतिपयस्वतन्त्रकार्ययुक्तस्य कार्यक्रमस्य" अनुरूपः भवति तथापि कार्यक्रमस्य एव अतिरिक्तं प्रक्रियायाः दत्तांशस्य (यत् संसाधनरूपेण अवगन्तुं शक्यते) प्रक्रियानियन्त्रणखण्डानां च आवश्यकता भवति यदा कश्चन कार्यक्रमः चालितः भवति तदा कार्यक्रमः एतेषु संसाधनेषु अवलम्बते, यत् वयं "प्रक्रिया" इति वदामः ।

प्रक्रियाणां मूलभूतगुणद्वयम् : १.

प्रक्रिया एकः स्वतन्त्रः एककः अस्ति यः संसाधनानाम् स्वामित्वं कर्तुं शक्नोति;
प्रक्रिया एकः मूलभूतः एककः अस्ति यस्य समयनिर्धारणं प्रेषणं च कर्तुं शक्यते ।
यदा प्रथमवारं सूत्राणि स्थापितानि आसन् तदा प्रक्रियायाः उपर्युक्तौ विशेषताद्वयं पृथक् कर्तुं आसीत् धागाः "CPU समयनिर्धारणस्य प्रेषणस्य च मूलभूतं एककं" भवन्ति and dispatch threads to better इदं प्रक्रियाणां समानान्तरनिष्पादनं साक्षात्कर्तुं शक्नोति एकस्मिन् समये, एकस्यामेव प्रक्रियायाः अन्तर्गतं धागाः प्रक्रियायाः सर्वाणि संसाधनानि साझां कर्तुं शक्नुवन्ति, ये एकस्यामेव प्रक्रियायाः अन्तर्गतं भिन्न-भिन्न-सूत्रैः प्रक्रिया-संसाधनानाम् अभिगमनं तृप्तुं शक्नुवन्ति सूत्राणां उद्भवः चतुराईपूर्वकं प्रक्रियायाः गुणद्वयं पृथक् करोति, येन प्रक्रिया समानान्तरनिष्पादनस्य आवश्यकताः उत्तमरीत्या सम्पादयितुं शक्नोति

सूत्रं चालितं कार्यं भवति । POSIX थ्रेड् मानकानां समुच्चयः अस्ति, न तु कार्यान्वयनस्य समुच्चयः । अन्ये मानकानि सन्ति यथा: openmp threads ।
Thread identifier: pthread_t (अहं विशिष्टां सामग्रीं न जानामि, प्रत्येकं कम्पनी भिन्नरूपेण कार्यान्वितं करोति, Linux इत्यस्य अन्तर्गतं int अस्ति)
px axm आदेशः प्रक्रियाः थ्रेड् च पश्यति - प्रक्रियायाः अन्तर्गतं थ्रेड् प्रतिनिधित्वं करोति । px ax -L लघुसूत्राणि द्रष्टुं ।

int pthread_equal (pthread_t t1, pthread_t t2); यदि ते समानाः सन्ति तर्हि अशून्यं प्रत्यागच्छति यदि ते भिन्नाः सन्ति तर्हि 0 प्रत्यागच्छति ।
pthread_t pthread_self (void);

2. सूत्राणां निर्माणम्

int pthread_create (pthread_t * धागा, const pthread_attr_t * attr,
शून्य * (* आरंभ_रूटीन) (शून्य *), शून्य * आर्ग);
थ्रेड् शेड्यूलिंग् शेड्यूलरस्य रणनीत्याः उपरि निर्भरं भवति ।

सृजन्१.ग

  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() फंक्शन् आह्वयति । शून्य pthread_exit (शून्य * retval);

int pthread_join(pthread_t thread, 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 (); //atexit के बराबर
pthread_cleanup_pop(); //सक्रियरूपेण आँकडानां आनयनस्य बराबरम्।

void pthread_cleanup_push (void (* routine)(void *), पूर्वसंसाधनं द्रष्टुं मैक्रो, gcc -E इत्यस्य कार्यान्वयनम् अस्ति
शून्य * आर्ग);
void pthread_cleanup_pop (int निष्पादित करें);युग्मरूपेण अवश्यं दृश्यते, मैक्रोभिः सह कार्यान्वितम्

स्वच्छता।ग

  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; रद्दीकरणबिन्दुपर्यन्तं विलम्बितप्रतिसादः ।
Cancal point: Posix द्वारा परिभाषिताः cancel बिन्दुः सिस्टम् आह्वानं भवति यत् जामस्य कारणं भवितुम् अर्हति ।
pthread_setcancelstate: रद्दीकरणस्थितिः सेट् कर्तुं शक्यते।
pthread_setcanceltype: भवान् रद्दीकरणविधिं सेट् कर्तुं शक्नोति।
pthread_testcancel: फंक्शन् किमपि न करोति, केवलं बिन्दुं रद्दं करोति ।

धागा विच्छेद: int pthread_detach (pthread_t धागा);

गतिशील मॉड्यूल एकल आरंभीकरण फ़ंक्शन: int pthread_once (pthread_once_t * एक बार_नियंत्रण,
शून्य (* आरंभ_दिनचर्या) (शून्य));
pthread_once_t एक बार_नियंत्रण = PTHREAD_एकदा_INIT;
 

उदाहरणम् १
  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.  }

उपर्युक्तसङ्केतस्य चालने स्पर्धा भविष्यति । यतः मापदण्डाः पताद्वारा पारिताः भवन्ति, तस्मात् दत्तांशं * द्वारा पुनः प्राप्तुं आवश्यकं भवति, पूर्वसूत्रेण कार्यं कृतम् अस्ति वा इति गारण्टी नास्ति सरलतमः विधिः मूल्यपारीकरणस्य उपयोगः

प्राइमर०.ग

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

प्राइमर०_ई.सी

  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.  }
उदाहरणम् २

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

यदा विंशतिः सूत्राः एकस्मिन् समये सञ्चिकायां दत्तांशं पठन्ति लिखन्ति च तदा स्पर्धा, विग्रहाः च भवितुम् अर्हन्ति । एकः सूत्रः लेखितुं पूर्वं अन्यः सूत्रः अन्तिमदत्तांशं पठति ।

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 * म्यूटेक्स);
int pthread_mutex_init (pthread_mutex_t * म्यूटेक्स प्रतिबन्धित,
const pthread_mutexattr_t * गतिशील आरंभीकरण प्रतिबन्धित करें;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER स्थिर आरंभीकरण;

int pthread_mutex_lock (pthread_mutex_t * म्यूटेक्स); //加锁
int pthread_mutex_trylock (pthread_mutex_t *mutex);//लॉक कर्तुं प्रयतस्व, यदि न, निष्पादनं निरन्तरं कुर्वन्तु
int pthread_mutex_unlock (pthread_mutex_t * म्यूटेक्स);//解锁

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
तालान् अनलॉक् कर्तुं च श्रृङ्खलायाः उपयोगं कुर्वन्तु।

  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 * प्रतिबन्धित cond,
const pthread_condattr_t * प्रतिबन्ध attr);
pthread_cond_t cond = PTHREAD_COND_आरम्भक;
int pthread_cond_broadcast (pthread_cond_t * cond);
int pthread_cond_signal (pthread_cond_t * cond);//किसी भी प्रतीक्षा जागें
int pthread_cond_timedwait (pthread_cond_t * cond प्रतिबंधित करें, //समय समाप्त प्रतीक्षा
pthread_mutex_t * म्यूटेक्स प्रतिबन्धित,
const struct timespec * परहेज प्रतिबन्धित);
int pthread_cond_wait (pthread_cond_t * cond प्रतिबंधित करें, //死等
pthread_mutex_t * म्यूटेक्स प्रतिबन्धित करें);

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

प्राइमर0_पूल.ग

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

संकेतः

म्यूटेक्स् 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.

म्यसेम्.ह

  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

पठन-लेखन ताला

म्यूटेक्सस्य सेमाफोरस्य च व्यापकः प्रयोगः । read lock (semaphore) तथा write lock (mutex) इति विभक्तम् । सामान्यतया पठनलेखनयोः उच्चसीमा निर्धारितव्या ।

लेखकानां बुभुक्षायाः निवारणं आवश्यकम् ।

4. सूत्रसम्बद्धाः गुणाः

pthread_create इत्यस्य द्वितीयः पैरामीटर् थ्रेड् इत्यस्य विशेषता अस्ति ।

int pthread_attr_init (पीथ्रेड_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. }

सूत्रसमन्वयनगुणाः

म्यूटेक्स गुणाः : १.

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, 1999।
int pshared);

//एकं बालप्रक्रिया रचयन्तु यत् सञ्चिकावर्णकसरणीं साझां कर्तुं शक्नोति भवान् तत् साझां न कर्तुं अपि चयनं कर्तुं शक्नोति। Linux इत्यस्य अन्तर्गतं प्रक्रियाणां सूत्राणां च भेदः नास्ति
int क्लोन (int (* fn) (शून्य *), शून्य * ढेर, int ध्वज, शून्य * arg, ...
/* pid_t * माता-पिता_tid, शून्य * tls, pid_t * बच्चा_tid */ );
int pthread_mutexattr_gettype (const pthread_mutexattr_t * प्रतिबन्ध attr,
int * प्रकार प्रतिबन्धित);
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. पुनः प्रवेशः

पुनः प्रवेशकः कार्यं केवलं एकं कार्यं भवति यत् तस्य निष्पादनस्य समये कदापि एतत् कार्यं बाधितुं शक्नोति तथा च नियन्त्रणं प्रत्यागत्य अन्यस्य कोडस्य भागस्य निष्पादनार्थं OS scheduling इत्यत्र स्थानान्तरणं कर्तुं शक्नोति कार्याणि केचन प्रणालीसंसाधनानाम् उपयोगं कुर्वन्ति, यथा वैश्विकचरक्षेत्राणि, व्यत्ययसदिशसारणी इत्यादयः, अतः यदि ते बाधिताः भवन्ति तर्हि एतादृशाः कार्याणि बहुकार्यवातावरणे चालयितुं न शक्नुवन्ति

बहुसूत्रीकरणे IO । अनलॉक्ड् फंक्शन् (अ-पुनःप्रवेशकः फंक्शन्, बहु-थ्रेडेड् समवर्ती समर्थितः नास्ति) इत्यनेन समाप्तः भवति । man putc_unlocked, असमर्थित IO कार्याणि पश्यन्तु।

सूत्राणि संकेतानि च

int pthread_sigmask (int कैसे, const sigset_t * सेट, sigset_t * oldset);
int sigwait (const sigset_t * सेट, int * सिग);
int pthread_kill (pthread_t धागा, int सिग);

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

संकलितं नमस्कारं कृत्वा चालयन्तु।

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

व्यक्तिगत प्रोफाइल

सः ३० वर्षाणाम् अनुसरणं प्रौयोगिक क्रमबद्धता युक्तं, आलंकार, जावा, जावास्विस्च, ph, css, सद्भावना संस्कृती, ph, css निर्वहनशील भाषा सुनावंश, ससरोत विद्वान विपक्षी विद्वान विनियोग विनियोग विनियोग विनियोग्य विवेचन विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग

मम सम्पर्कसूचना

मेल