• C语言：高级并发操作（线程）

    一、线程的概念

    线程：进程中的一个实体，是CPU调度和分派的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。线程在运行中呈现间断性。（以上来自《计算机四级教程——操作系统原理》）

    谈到线程，就有必要说说进程的定义：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。（以上来自《计算机四级教程——操作系统原理》）

    进程的定义有点绕口，我们看看进程由什么组成：程序、数据和进程控制块。其中程序，对应进程定义中“具有一定独立功能的程序”，但是进程除了程序本身，还需要有数据（可以理解为资源），以及，进程控制块。数据和进程控制块是程序运行时必不可少的资源，程序依赖这些资源进行相应的活动，就是我们说的“进程”了。

    进程的两个基本属性：

    进程是一个可拥有资源的独立单位；
    进程是一个可以独立调度和分派的基本单位。
    线程建立之初，就是为了将进程的上述两个属性分开，线程构成了“CPU调度和分派的基本单位”，这样一个进程中可以有很多线程，操作系统对线程进行调度和分派，可以更好地实现进程的并打执行；同时同一个进程下的线程可以共享该进程的全部资源，可以满足同一个进程下不同线程对进程资源的访问。线程的出现，巧妙地将进程的两个属性分开，使得进程可以更好地处理并行执行的需求。

    线程就是一个正在运行的函数。posix线程是一套标准，而不是一套实现。还有别的标准如：openmp线程。
    线程标识：pthread_t (不知道具体的内容，各家实现不同，linux下是int)
    px axm命令 看到进程和线程--代表进程下的线程。 px ax -L查看轻量级线程。        

           int pthread_equal(pthread_t t1, pthread_t t2); 比较两个线程的ID号。相同返回非0，不同返回0.
           pthread_t pthread_self(void); 获取当前线程的线程ID

    二、线程的创建

           int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                              void *(*start_routine) (void *), void *arg);
    线程的调度取决与调度器的策略。

    create1.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    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 thread, void **retval); 相当于进程的wait，用于收尸。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    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 *arg);
           void pthread_cleanup_pop(int execute); //选择是否调用。必须成对出现，用宏实现

    cleanup.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    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 thread);
            取消有两种状态：允许和不允许。
            不允许取消：继续执行代码，不受任何影响。
            允许取消又分为：异步cancel,和推迟cancel(默认)->推迟到cancel点在响应。
            cancal点：Posix定义的cancel点，都是可能引发堵塞的系统调用。
            pthread_setcancelstate：可以设置取消状态。
            pthread_setcanceltype：可以设置取消方式。
            pthread_testcancel：函数什么都不做，就是取消点。

    线程分离：       int pthread_detach(pthread_t thread);

      动态模块单次初始化函数：int pthread_once(pthread_once_t *once_control,
               void (*init_routine)(void));
           pthread_once_t once_control = PTHREAD_ONCE_INIT;
     

         实例1
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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():%s\n",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;j2;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.  }

    以上代码运行会出现竞争的现象。因为传递参数用的是地址传参，数据需要取*才能拿到，不能保证上一个线程是否进行了该操作，最简单的是使用值传递。

    primer0.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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():%s\n",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;j2;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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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():%s\n",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;j2;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 

    add.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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():%s\n",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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    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
    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
    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 error\n");
    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. }

    三、线程同步

    互斥量

    相当于一把锁，必须先进行解锁才能操作。（查询法）
    如果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);//解锁

    add.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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
    20.     {
    21.         err= pthread_create(tid+(i),NULL,thr_add,NULL);
    22.         if(err)
    23.         {
    24.             fprintf(stderr,"pthread_create():%s\n",strerror(err));
    25.         }
    26.     }
    27.  
    28.     for(i=0;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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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
    20.     {
    21.         err= pthread_create(tid+(i),NULL,thr_abcd,(void*)i);
    22.         if(err)
    23.         {
    24.             fprintf(stderr,"pthread_create():%s\n",strerror(err));
    25.         }
    26.     }
    27.     alarm(2);
    28.  
    29.     for(i=0;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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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
    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():%s\n",strerror(err));
    28.         }
    29.     }
    30.     pthread_mutex_unlock(mut+0);
    31.     alarm(2);
    32.  
    33.     for(i=0;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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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():%s\n",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;j2;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, //超时等待
               pthread_mutex_t *restrict mutex,
               const struct timespec *restrict abstime);
           int pthread_cond_wait(pthread_cond_t *restrict cond, //死等
               pthread_mutex_t *restrict mutex);

    mytbf.c（通知法）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    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
    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
    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 error\n");
    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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    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():%s\n",strerror(err));
    30.         }
    31.     }
    32.     //下发任务
    33.     for(i=LEFT;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;j2;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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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
    22.     {
    23.  
    24.         err= pthread_create(tid+(i),NULL,thr_abcd,(void*)i);
    25.         if(err)
    26.         {
    27.             fprintf(stderr,"pthread_create():%s\n",strerror(err));
    28.         }
    29.     }
    30.     
    31.     alarm(2);
    32.  
    33.     for(i=0;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类型，信号量（semaphore）是int类型，使用的时候进行自减，不够就等待。

    mysem.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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 
    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 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    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():%s\n",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;j2;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

    读写锁

    互斥量和信号量的综合使用。分为读锁（信号量）和写锁（互斥量）。一般读写要设置上限。

    需要防止写者饿死的情况发生。

    四、线程相关属性

    pthread_create第二个参数是线程的属性。

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

    测试程序创建最大线程个数。（）

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. void* func(void)
    6. {
    7.     int i;
    8.  
    9. //    printf("%p\n",&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 err\n");
    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);
           Refer to 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 type);

    条件变量属性：       
           int pthread_condattr_destroy(pthread_condattr_t *attr);
           int pthread_condattr_init(pthread_condattr_t *attr);
    读写锁属性：

    五、重入

    一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误；而不可重入的函数由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。

    多线程中的IO。unlocked函数结尾的都是（不可重入函数,不支持多线程并发）。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 thread, int sig);

    openmp线程标准

    参考官网：www.OpenMp.org

    gcc4.0之后都支持openmp语法标记。有几个CPU就可以实现多少并发

    hello.c

    1. #include 
    2. #include 
    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

    make hello编译，并且运行。

    1. #include 
    2. #include 
    3. #include 
    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. }

  • 相关阅读:
    mysql改造oracle，以及项目改造
    Spring框架系列(3) - 深入浅出Spring核心之控制反转(IOC)
    xshell报错-要继续使用此程序,您必须应用最新的更新或使用新版本
    [Vite]import.meta.glob批量引入svg图片
    Lua学习笔记：在Visual Studio中调试Lua源码和打断点
    C Primer Plus(6) 中文版 第10章 数组和指针 10.3 指针和数组
    【Redis】Java Spring操作redis
    spfa判断负环的应用
    严把质量关，饮片追溯系统应用，信息化追溯助力用药安全-亿发
    C++数据结构X篇_24_归并排序(稳定的排序)
  • 原文地址：https://blog.csdn.net/m0_58233509/article/details/139998344