Technology sharing

C lingua: concurrency provectus operationes (stamina)

2024-07-12

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

1. De conceptu sequelae

Post: Ens in processu et in basic unitas CPU scheduling et litterae. Ipsum filum basically facultates systematis proprias non habet, paucae tantum facultates quae ad currendum necessariae sunt (sicut programma calculi, tabulae tabulae, et acervus), sed communicare potest omnes facultates quae processu cum aliis sequelis habent. quae ad eundem processum pertinent. Filum aliud stamen creare et destruere potest; Fila monstrant mores intermittendi in operatione. (Superius est ex "Computer Level 4 Tutorialis - Ratio Principia Operating")

Cum fila venit, loqui necesse est de definitione processus: processus est programma cum quibusdam functionibus independentibus. (Superius est ex "Computer Level 4 Tutorialis - Ratio Principia Operating")

Definitio processus est aliquantulus perplexa. Inspiciamus quid sit processus: progressio, notitia et processus imperium scandalum. Inter eos, programma respondet "programma cum quibusdam functionibus independentibus" in definitione processus. Data et processus imperium insulis essentiales sunt facultates cum programma currit.

Duae processus principales proprietates:

Processus est unitas independentis quae proprias facultates habere potest;
Processus fundamentalis unitas est quae independenter a schedule et mitti potest.
Cum stamina primum constituta sunt, illa duo processus attributa dividere erat. Fila constituunt "unitatem fundamentalem CPU scheduling et mittentem." et stamina in melius mitti. Potest cognoscere processuum exsecutionem parallelam; simul, fila sub eodem processu omnes facultates processus communicare, quae accessum facultatum processuum diversis stamina sub eodem processu explere possunt. Cessus filorum duo attributa processus callide separat, sino processu ut melius necessarias exsecutionis parallelae tractaret.

Filum munus currens est. Stamina POSIX signa sunt copia, non exsecutiones copiae. Alia sunt signa ut: fila openmp.
Thread identifier: pthread_t (Non novi contentum specificum, singulae societatis instrumentum aliter id, sub Linux int)
Mandatum px axm processus et fila videt - fila repraesentans sub processu. px securi -L ad view relatorum leve.

int pthread_equal(pthread_t t1, pthread_t t2). Si eadem sunt, non- nulla redditur;
pthread_t pthread_self(inanis);

2. De creatione relatorum

int pthread_create (pthread_t * stamina const pthread_attr_t * attr,
void *(*start_routine) (void *), void *arg);
Post scheduling dependet a consilio schedularum.

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

Post terminationem

1. Sequela ab exercitatione startup redit, et valor reditus est exitus sequelae.
2. Fila alia fila in eodem processu cassari possunt.
3. Filum vocat munus pthread_exit(). void pthread_exit(void *retval);

int pthread_join(pthread_t thread, inanis 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. }

BIBLIOTHECA tersus

pthread_cleanup_push();
pthread_cleanup_pop();

inanis pthread_cleanup_push(inanis (*routine)(inanis *) est exsecutio tortor, gcc -E ad visum preprocessing
void *arg);
vacui pthread_cleanup_pop(int exequi);Apparebit paria, cum macros implemented

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

Abrigavi optiones relatorum

Si filum currens vult colligere cadaver, oportet primum delere et deinde corpus colligere (pthread_join).

Post tabulae novae: int pthread_cancel(pthread_t thread);
Receptatio duos status habet: licet et non licet.
Indultum receptae non conceditur: signum exsecutionis sine impedimento pergit.
Permissa indultum dividitur in: asynchronum inrita, et retardatum inrita (default) -&gt; responsionis tardae usque ad punctum inrita.
Punctum cancale: Excludit puncta quae Posix definita sunt systema vocat quae obstructionem causare possunt.
pthread_setcancelstate: Abrigavi publica statui potest.
pthread_setcanceltype: Tabulae novae modum constituere potes.
pthread_testcancel: Munus nihil agit, solum punctum tollit.

Reticulum: int pthread_detach(pthread_t thread);

Dynamici moduli unius functionis initialization: int pthread_once(pthread_once_t *once_control,
inanis (*init_routine)(inanis));
pthread_once_t once_control = PTHREAD_ONCE_INIT;
 

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

Certamen erit cum curritur supra codicem. Quia parametri electronici praetereunt, notitia insanabilis * est, et nulla est cautio an prior filo operationem perficiat.

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

Certamen et pugnae fieri possunt cum viginti stamina data in tabella simul legere et scribere. Priusquam unum stamen scribit in, aliud stamen ultimam datam legit.

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. Post synchronisation

mutex

Aequale est seram et debet reserari antequam operari possit. (Quaestio modum)
Si homo pthread_mutex_init errorem tradit, clientelas instituere placet:
sudo facile adepto install manpages posix manpages posix-dev

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

int pthread_mutex_lock (pthread_mutex_t * Mutex); //
int pthread_mutex_trylock (pthread_mutex_t * Mutex); // Try ad cincinno, nisi pergere supplicium
int pthread_mutex_unlock (pthread_mutex_t * Mutex); //解锁

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*
Utere catenam cohibere ac reserare.

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

Piscina algorithmus instrumentum numeri primi calculi (quaestio methodus)

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

conditio variabilis

Notification Act communicationis.

int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init (pthread_cond_t * restringere 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); // Surge omnis insidias
int pthread_cond_timedwait (pthread_cond_t * restringere condne, // timeout insidias
pthread_mutex_t * restringere mutex,
const struct timespec *restrict abstime);
int pthread_cond_wait (pthread_cond_t * restringere cond, //死等
pthread_mutex_t *mutex restringere);

mytbf.c (notitia modum)

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

signum

Mutex est genus bool, et semaphore 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

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

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

legere-scribere cincinno

Mutexum et semaphorum usum comprehensive. Divisa in lege cincinno (semaphore) et cincinno scribe (mutex). Generaliter, superior modus legendi et scribendi debet poni.

Necesse est ne scriptores fame pereant.

4. Post actis attributorum

Secundus parametri pthread_creati attributus est sequela.

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

Maximus numerus relatorum a programmate experimentali creatus est. ()

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

Post synchronisation proprietatibus

Mutex possessiones;

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
Refer ad pthread_mutexattr_destroy().
int pthread_mutexattr_getpshared (const pthread_mutexattr_t * attr, // operatur per processuum
int * pshared);
int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
int pshared);

// Creare puerum processum qui tabellae descriptor ordinata communicare potest. Nulla distinctio processuum et staminum sub Linux
int clone(int (*fn)(void*), void *stack, int flags, void *arg, ...
/*pid_t *parent_tid, inanis *tls, pid_t *child_tid */ );
int pthread_mutexattr_gettype (const pthread_mutexattr_t * restringere attr,
int *restrict type);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

Conditio variabilis possessiones:
int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);
Legere proprietatibus scribere, cincinno:

5. Re-introitus

Munus reentrantis est simpliciter functio quae interpellari potest. Hoc est, nempe, munus hoc quovis tempore interrumpere et in eius executione transferre ad OS scheduling ad exequendum alium codicem sine ullis erroribus cum potestate redeuntis functiones aliquas facultates systematis utuntur, ut global variabiles areas, tabulas vector interrumpunt, etc., si intermittuntur, problemata occurrere possunt.

IO in multiplicatione. Munus reserata cum extremis (munus non-reentrantis, multi- liciatorum concursus non praebetur). homo putc_reclusus, visum sine IO operatione.

Stamina et annuit

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 thread, int sig);

openmp vexillum filum

Refer ad rutrum: www.OpenMp.org

Openmp syntax tags are supported after gcc4.0.Quot concursus cum paucis CPUs effici potest?

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

makefile

CFLAGS += -Wall -fopenmp

Compile salve et curre fac.

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

Personal profile

technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones technologiarum progressus ad futuram referentiam

mihi contactus notitia

Mail