• Linux学习——线程的取消和互斥

    目录

    一、线程的取消：(pthread_cancel)

    运行段错误调试：

    如果没有取消点，手动设置一个

    设置取消使能或禁止

    设置取消类型

    二、线程的清理(pthread (_cleanup_push  _cleanup_pop))

    三、线程通信——互斥

    临界资源概念：

    man手册找不到 pthread_mutex_xxxxxxx （提示No manual entry for pthread_mutex_xxx）的解决方法：

    互斥锁的创建和销毁

    申请锁——pthread_mutex_lock

    释放锁——pthread_mutex_unlock 

    互斥锁的使用：

    四、读写锁

    五、死锁

    概念：

    避免方法：

    一、线程的取消：(pthread_cancel)

    别的大佬的文章：

    linux c学习笔记----线程创建与终止 - 极客先锋 - 博客园

    意义：随时杀掉一个线程

    int pthread_cancel(pthread_t thread);

    注意：线程的取消要有取消点才可以，不是说取消就取消，线程的取消点主要是阻塞的系统调用

    运行段错误调试：

    可以使用gdb调试

    使用gdb 运行代码，gdb  ./youapp

    (gdb) run

    等待出现Thread 1 "pcancel" received signal SIGSEGV, Segmentation fault.

    输入命令bt（打印调用栈）

    (gdb) bt

    #0  0x00007ffff783ecd0 in vfprintf () from /lib/x86_64-linux-gnu/libc.so.6

    #1  0x00007ffff78458a9 in printf () from /lib/x86_64-linux-gnu/libc.so.6

    #2  0x00000000004007f9 in main () at pcancel.c:21

    确定段错误位置是pcancel.c 21行

    如果没有取消点，手动设置一个

    void pthread_testcancel(void);

    设置取消使能或禁止

    int pthread_setcancelstate(int state, int *oldstate);

    PTHREAD_CANCEL_ENABLE

    PTHREAD_CANCEL_DISABLE  //不能取消

    设置取消类型

    int pthread_setcanceltype(int type, int *oldtype);

    PTHREAD_CANCEL_DEFERRED                等到取消点才取消    延时取消

    PTHREAD_CANCEL_ASYNCHRONOUS           目标线程会立即取消     异步取消

    实验程序;

    1. #include 
    2. #include 
    3. #include 
    4. void *func(void *arg){
    5.     printf("This is child thread\n");
    6.     pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);    
    7. //    while(1)
    8.     {
    9.         sleep(5);
    10.         pthread_testcancel();
    11.     }
    12.     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
    13.     while(1){
    14.         sleep(1);
    15.     }
    16.  
    17.  
    18.     pthread_exit("thread return");
    19. }
    20.  
    21.  
    22. int main(){
    23.     pthread_t tid;
    24.     void *retv;
    25.     int i;
    26.     pthread_create(&tid,NULL,func,NULL);
    27.     sleep(1);
    28.     pthread_cancel(tid);
    29.     pthread_join(tid,&retv);
    30. //    printf("thread ret=%s\n",(char*)retv);
    31.     while(1){    
    32.         sleep(1);
    33.     } 
    34.  
    35. }

    二、线程的清理(pthread (_cleanup_push  _cleanup_pop))

    必要性： 当线程非正常终止，需要清理一些资源。

    void pthread_cleanup_push(void (*routine) (void *), void *arg)

    void pthread_cleanup_pop(int execute)

    routine 函数被执行的条件：

    1. 被pthread_cancel取消掉。
    2. 执行pthread_exit
    3. 非0参数执行pthread_cleanup_pop()

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void *func(void *arg){
    10. 	printf("This is child thread\n");
    11. 	pthread_cleanup_push(cleanup,"abcd");
    12. 	pthread_exit("thread return");
    13. 	while(1){    
    14.         sleep(1);
    15.     }
    16. 	pthread_cleanup_pop(0);
    17. }
    18.  
    19.  
    20. int main(){
    21.     pthread_t tid;
    22.     void *retv;
    23.     int i;
    24.     pthread_create(&tid,NULL,func,NULL);
    25.     sleep(1);
    26.     pthread_cancel(tid);
    27.     pthread_join(tid,&retv);
    28.     //printf("thread ret=%s\n",(char*)retv);
    29.     while(1){    
    30.         sleep(1);
    31.     } 
    32. 	
    33. }
    34. #endif

    结果：

     当程序改为：

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void *func(void *arg){
    10. 	printf("This is child thread\n");
    11. 	pthread_cleanup_push(cleanup,"abcd");
    12. 	pthread_exit("thread return");
    13. 	//while(1){    
    14.         sleep(1);
    15.     //}
    16. 	pthread_cleanup_pop(0);
    17. }
    18.  
    19.  
    20. int main(){
    21.     pthread_t tid;
    22.     void *retv;
    23.     int i;
    24.     pthread_create(&tid,NULL,func,NULL);
    25.     sleep(1);
    26.     //pthread_cancel(tid);
    27.     pthread_join(tid,&retv);
    28.     //printf("thread ret=%s\n",(char*)retv);
    29.     while(1){    
    30.         sleep(1);
    31.     } 
    32. 	
    33. }
    34. #endif

    结果仍是：

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void *func(void *arg){
    10. 	printf("This is child thread\n");
    11. 	pthread_cleanup_push(cleanup,"abcd");
    12. 	//pthread_exit("thread return");
    13. 	//while(1){    
    14.         sleep(1);
    15.     //}
    16. 	pthread_cleanup_pop(0);
    17. 	pthread_exit("thread return");
    18. }
    19.  
    20.  
    21. int main(){
    22.     pthread_t tid;
    23.     void *retv;
    24.     int i;
    25.     pthread_create(&tid,NULL,func,NULL);
    26.     sleep(1);
    27.     //pthread_cancel(tid);
    28.     pthread_join(tid,&retv);
    29.     //printf("thread ret=%s\n",(char*)retv);
    30.     while(1){    
    31.         sleep(1);
    32.     } 
    33. 	
    34. }
    35. #endif

     结果：

    并没有执行cleanup，因为参数是0，将参数改成1后运行结果：

     

     在clean_up_pop后加上10秒的延时，cleanup依旧很快的就运行了，证明到pop就执行cleanup

     加上cleanup2看看谁先执行

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void cleanup2(void* arg){
    10.  
    11.     printf("cleanup2,arg=%s\n",(char*)arg);
    12. }
    13. void *func(void *arg){
    14. 	printf("This is child thread\n");
    15. 	pthread_cleanup_push(cleanup,"abcd");
    16. 	pthread_cleanup_push(cleanup2,"efgh");
    17. 	//pthread_exit("thread return");
    18. 	//while(1){    
    19.         sleep(1);
    20.     //}
    21. 	pthread_cleanup_pop(1);
    22. 	pthread_cleanup_pop(1);	
    23. 	sleep(10);
    24. 	pthread_exit("thread return");
    25. }
    26.  
    27.  
    28. int main(){
    29.     pthread_t tid;
    30.     void *retv;
    31.     int i;
    32.     pthread_create(&tid,NULL,func,NULL);
    33.     sleep(1);
    34.     //pthread_cancel(tid);
    35.     pthread_join(tid,&retv);
    36.     //printf("thread ret=%s\n",(char*)retv);
    37.     while(1){    
    38.         sleep(1);
    39.     } 
    40. 	
    41. }
    42. #endif

     运行结果：

    证明这个pop和push是像if---else一样成对出现的是先进后出的不用pop改用exit来结束结果相同

    下面试试让线程自己结束自己

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void cleanup2(void* arg){
    10.  
    11.     printf("cleanup2,arg=%s\n",(char*)arg);
    12. }
    13. void *func(void *arg){
    14. 	printf("This is child thread\n");
    15. 	pthread_cleanup_push(cleanup,"abcd");
    16. 	pthread_cleanup_push(cleanup2,"efgh");
    17. 	//pthread_exit("thread return");
    18. 	//while(1){    
    19.         sleep(1);
    20.     //}
    21. 	pthread_cancel(pthread_self());
    22. 	printf("Should not print\n");	
    23. 	
    24. 	pthread_exit("thread return");
    25. 	pthread_cleanup_pop(1);
    26. 	pthread_cleanup_pop(1);	
    27. 	sleep(10);
    28. 	pthread_exit("thread return");
    29. }
    30.  
    31.  
    32. int main(){
    33.     pthread_t tid;
    34.     void *retv;
    35.     int i;
    36.     pthread_create(&tid,NULL,func,NULL);
    37.     sleep(1);
    38.     //pthread_cancel(tid);
    39.     pthread_join(tid,&retv);
    40.     //printf("thread ret=%s\n",(char*)retv);
    41.     while(1){    
    42.         sleep(1);
    43.     } 
    44. 	
    45. }
    46. #endif

     结果：

    一个不应该出现的结果出现了，这里不应该打印证明他没有结束，原来是没有设置cancel的取消点，现在加上取消点，加个死循环阻塞系统：

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void cleanup2(void* arg){
    10.  
    11.     printf("cleanup2,arg=%s\n",(char*)arg);
    12. }
    13. void *func(void *arg){
    14. 	printf("This is child thread\n");
    15. 	pthread_cleanup_push(cleanup,"abcd");
    16. 	pthread_cleanup_push(cleanup2,"efgh");
    17. 	//pthread_exit("thread return");
    18. 	//while(1){    
    19.         sleep(1);
    20.     //}
    21. 	pthread_cancel(pthread_self());
    22. 	printf("Should not print\n");	
    23.  
    24.     while(1){
    25.         printf("sleep\n");
    26.         sleep(1);
    27.     }
    28. 	
    29. 	pthread_exit("thread return");
    30. 	pthread_cleanup_pop(1);
    31. 	pthread_cleanup_pop(1);	
    32. 	sleep(10);
    33. 	pthread_exit("thread return");
    34. }
    35.  
    36.  
    37. int main(){
    38.     pthread_t tid;
    39.     void *retv;
    40.     int i;
    41.     pthread_create(&tid,NULL,func,NULL);
    42.     sleep(1);
    43.     //pthread_cancel(tid);
    44.     pthread_join(tid,&retv);
    45.     //printf("thread ret=%s\n",(char*)retv);
    46.     while(1){    
    47.         sleep(1);
    48.     } 
    49. 	
    50. }
    51. #endif

     结果为：

    他还是不行原来是因为线程的停止不是立即执行的

    现在将参数改为立即执行：

    在前面加上

    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);

     结果为：

    现在就是立即取消状态了，没有打印出那句话，不设置的话默认为到取消点取消。 

    程序：
     

    1. #include 
    2. #include 
    3. #include 
    4. #if 1
    5. void cleanup(void *arg){
    6.     printf("cleanup,arg=%s\n",(char*)arg);
    7.  
    8. }
    9. void cleanup2(void* arg){
    10.  
    11.     printf("cleanup2,arg=%s\n",(char*)arg);
    12. }
    13. void *func(void *arg){
    14. 	printf("This is child thread\n");
    15.  
    16. 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    17.  
    18. 	pthread_cleanup_push(cleanup,"abcd");
    19. 	pthread_cleanup_push(cleanup2,"efgh");
    20. 	//pthread_exit("thread return");
    21. 	//while(1){    
    22.         sleep(1);
    23.     //}
    24. 	return "1234";
    25.  
    26. 	pthread_cancel(pthread_self());
    27. 	printf("Should not print\n");	
    28.  
    29.     while(1){
    30.         printf("sleep\n");
    31.         sleep(1);
    32.     }
    33. 	
    34. 	pthread_exit("thread return");
    35. 	pthread_cleanup_pop(1);
    36. 	pthread_cleanup_pop(1);	
    37. 	sleep(10);
    38. 	pthread_exit("thread return");
    39. }
    40.  
    41.  
    42. int main(){
    43.     pthread_t tid;
    44.     void *retv;
    45.     int i;
    46.     pthread_create(&tid,NULL,func,NULL);
    47.     sleep(1);
    48.     //pthread_cancel(tid);
    49.     pthread_join(tid,&retv);
    50.     //printf("thread ret=%s\n",(char*)retv);
    51.     while(1){    
    52.         sleep(1);
    53.     } 
    54. 	
    55. }
    56. #endif

    用return来结束线程，只有一个主线程，成功结束子线程：

    注意：

    1、必须成对使用，即使pthread_cleanup_pop不会被执行到也必须写上，否则编译错误。

    2、pthread_cleanup_pop()被执行且参数为0，pthread_cleanup_push回调函数routine不会被执行.

    3、pthread_cleanup_push 和pthread_cleanup_pop可以写多对，routine执行顺序正好相反

    4、线程内的return 可以结束线程，也可以给pthread_join返回值，但不能触发pthread_cleanup_push里面的回调函数，所以我们结束线程尽量使用pthread_exit退出线程。

    三、线程通信——互斥

    临界资源概念：

    不能同时访问的资源，比如写文件，只能由一个线程写，同时写会写乱。

    比如外设打印机，打印的时候只能由一个程序使用。

    外设基本上都是不能共享的资源。

    生活中比如卫生间，同一时间只能由一个人使用。

    必要性： 临界资源不可以共享

    临界区：访问临界资源的代码.。

    man手册找不到 pthread_mutex_xxxxxxx （提示No manual entry for pthread_mutex_xxx）的解决方法：

        apt-get install manpages-posix-dev

    又出现新问题：

    E: Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission denied)
    E: Unable to acquire the dpkg frontend lock (/var/lib/dpkg/lock-frontend), are you root?
    因为之前下载异常退出导致出现了锁，需要超级用户或者把锁删掉，具体解决办法看这个：

    linux安装软件问题解决（E: Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission de）_lihua且人机99的博客-CSDN博客

    互斥锁的创建和销毁

    两种方法创建互斥锁，静态方式和动态方式

    动态方式：

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

    其中mutexattr用于指定互斥锁属性，如果为NULL则使用缺省属性。

    静态方式：

    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

    锁的销毁：

    int pthread_mutex_destroy(pthread_mutex_t *mutex)

    在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

    申请锁——pthread_mutex_lock

    释放锁——pthread_mutex_unlock 

    互斥锁的使用：

    int pthread_mutex_lock(pthread_mutex_t *mutex)

    int pthread_mutex_unlock(pthread_mutex_t *mutex)

    int pthread_mutex_trylock(pthread_mutex_t *mutex)

    vim 设置代码全文格式化：gg=G

    usleep(1)//1毫秒释放CPU

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #if 1
    7. //pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    8. FILE *fp;
    9. void *func2(void *arg){
    10.     pthread_detach(pthread_self());
    11.     printf("This is func2 thread\n");
    12.     char str[]="You read func2 thread\n";
    13.     char c;
    14.     int i=0;
    15. 	while(1){
    16.         //pthread_mutex_lock(&mutex);
    17.         while(i<strlen(str))
    18.         {
    19.             c = str[i];
    20.             fputc(c,fp);
    21.             usleep(1);
    22.             i++;
    23.         }
    24.         //pthread_mutex_unlock(&mutex);
    25.         i=0;
    26.         usleep(1);
    27.  
    28.     }
    29. 	pthread_exit("func2 exit");
    30. }
    31. void *func(void *arg){
    32.     pthread_detach(pthread_self());
    33.     printf("This is func1 thread\n");
    34.     char str[]="I read func1 thread\n";
    35.     char c;
    36.     int i=0;
    37. 	while(1){
    38.         //pthread_mutex_lock(&mutex);
    39.         while(i<strlen(str))
    40.         {
    41.             c = str[i];
    42.             fputc(c,fp);
    43.             usleep(1);
    44.             i++;
    45.         }
    46.         //pthread_mutex_unlock(&mutex);
    47.         i=0;
    48.         usleep(1);
    49.  
    50.     }	
    51. 	pthread_exit("func1 exit");
    52. }
    53. int main()
    54. {
    55. 	pthread_t tid,tid2;
    56.     void *retv;
    57.     int i;
    58.     fp = fopen("1.txt","a+");
    59. 	if(fp == NULL){
    60. 		perror("fopen");
    61. 		return 0;
    62. 	}
    63.  
    64.     pthread_create(&tid,NULL,func,NULL);
    65.     pthread_create(&tid2,NULL,func2,NULL);
    66.     while(1){    
    67.         sleep(1);
    68.     } 
    69.  
    70. }
    71.  
    72.  
    73. #endif

    结果：

     

     由于没有加锁两个线程同时向1.txt写入，导致出现这种奇怪的东西，为了正常写入加入互斥锁，就是将上面的程序注释掉的地方不注释结果如下：

    四、读写锁

    必要性：提高线程执行效率

    特性：

    写者：写者使用写锁，如果当前没有读者，也没有其他写者，写者立即获得写锁；否则写者将等待，直到没有读者和写者。

    读者：读者使用读锁，如果当前没有写者，读者立即获得读锁；否则读者等待，直到没有写者。

    注意：

    同一时刻只有一个线程可以获得写锁，同一时刻可以有多个线程获得读锁。

    读写锁出于写锁状态时，所有试图对读写锁加锁的线程，不管是读者试图加读锁，还是写者试图加写锁，都会被阻塞。

    读写锁处于读锁状态时，有写者试图加写锁时，之后的其他线程的读锁请求会被阻塞，以避免写者长时间的不写锁

    初始化一个读写锁   pthread_rwlock_init

    读锁定读写锁       pthread_rwlock_rdlock

    非阻塞读锁定　　   pthread_rwlock_tryrdlock

    写锁定读写锁      pthread_rwlock_wrlock

    非阻塞写锁定      pthread_rwlock_trywrlock

    解锁读写锁         pthread_rwlock_unlock

    释放读写锁         pthread_rwlock_destroy

    当他是读锁时（pthread_rwlock_rdlock）：

     当他是写锁时（pthread_rwlock_wrlock）

    加上rewind（fp）在读写之间加一个3秒休眠线程一读完线程二读

    在还没读完的时候强制退出发现并没有进行写操作可以同时读但不能同时写。

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6.  
    7. pthread_rwlock_t rwlock;
    8.  
    9. FILE *fp;
    10. void * read_func(void *arg){
    11.     pthread_detach(pthread_self());
    12.     printf("read thread\n");
    13.     char buf[32]={0};
    14.     while(1){
    15.         //rewind(fp);
    16.         pthread_rwlock_rdlock(&rwlock);
    17.         while(fgets(buf,32,fp)!=NULL){
    18.             printf("%d,rd=%s\n",(int)arg,buf);
    19.             usleep(1000);
    20.         }
    21.         pthread_rwlock_unlock(&rwlock);
    22.         sleep(1);
    23.     }
    24.  
    25. }
    26.  
    27. void *func2(void *arg){
    28.     pthread_detach(pthread_self());
    29.     printf("This func2 thread\n");
    30.     
    31.     char str[]="I write func2 line\n";
    32.     char c;
    33.     int i=0;
    34.     while(1){
    35.         pthread_rwlock_wrlock(&rwlock);
    36.         while(i<strlen(str))
    37.         {
    38.             c = str[i];
    39.             fputc(c,fp);
    40.             usleep(1);
    41.             i++;
    42.         }
    43.         pthread_rwlock_unlock(&rwlock);
    44.         i=0;
    45.         usleep(1);
    46.  
    47.     }
    48.  
    49.     pthread_exit("func2 exit");
    50.  
    51. }
    52.  
    53. void *func(void *arg){
    54.     pthread_detach(pthread_self());
    55.     printf("This is func1 thread\n");
    56.     char str[]="You read func1 thread\n";
    57.     char c;
    58.     int i=0;
    59.     while(1){
    60.         pthread_rwlock_wrlock(&rwlock);
    61.         while(i<strlen(str))
    62.         {
    63.             c = str[i];
    64.             fputc(c,fp);
    65.             i++;
    66.             usleep(1);
    67.         }
    68.         pthread_rwlock_unlock(&rwlock);
    69.         i=0;
    70.         usleep(1);
    71.     }
    72.     pthread_exit("func1 exit");
    73. }
    74.  
    75.  
    76. int main(){
    77.     pthread_t tid1,tid2,tid3,tid4;
    78.     void *retv;
    79.     int i;
    80.     fp = fopen("1.txt","a+");
    81.     if(fp==NULL){
    82.         perror("fopen");
    83.         return 0;
    84.     }
    85.     pthread_rwlock_init(&rwlock,NULL);
    86.     pthread_create(&tid1,NULL,read_func,1);
    87.     pthread_create(&tid2,NULL,read_func,2);
    88. 	//sleep(3);
    89.     pthread_create(&tid3,NULL,func,NULL);
    90.     pthread_create(&tid4,NULL,func2,NULL);
    91.     while(1){    
    92.         sleep(1);
    93.     } 
    94.  
    95. }
    96.

    五、死锁

    概念：

    死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

    死锁_百度百科

    避免方法：

    1. 锁越少越好，最好使用一把锁
    2. 调整好锁的顺序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    7. pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
    8.  
    9. FILE *fp;
    10. void *func2(void *arg){
    11.     pthread_detach(pthread_self());
    12.     printf("This func2 thread\n");
    13.     
    14.     char str[]="I write func2 line\n";
    15.     char c;
    16.     int i=0;
    17.     while(1){
    18.         pthread_mutex_lock(&mutex);
    19.         printf("%d,I got lock2\n",(int)arg);
    20.         sleep(1);
    21.         pthread_mutex_lock(&mutex2);
    22.         printf("%d,I got 2 locks\n",(int)arg);
    23.  
    24.         pthread_mutex_unlock(&mutex2);
    25.         pthread_mutex_unlock(&mutex);
    26.         sleep(10);
    27.  
    28.     }
    29.  
    30.     pthread_exit("func2 exit");
    31.  
    32. }
    33.  
    34. void *func(void *arg){
    35.     pthread_detach(pthread_self());
    36.     printf("This is func1 thread\n");
    37.     char str[]="You read func1 thread\n";
    38.     char c;
    39.     int i=0;
    40.     while(1){
    41.         pthread_mutex_lock(&mutex);
    42.         printf("%d,I got lock1\n",(int)arg);
    43.         sleep(1);
    44.         pthread_mutex_lock(&mutex2);
    45.         printf("%d,I got 2 locks\n",(int)arg);
    46.  
    47.         pthread_mutex_unlock(&mutex2);
    48.         pthread_mutex_unlock(&mutex);
    49.         sleep(10);
    50.  
    51.     }
    52.     pthread_exit("func1 exit");
    53. }
    54.  
    55.  
    56. int main(){
    57.     pthread_t tid,tid2;
    58.     void *retv;
    59.     int i;
    60.     fp = fopen("1.txt","a+");
    61.     if(fp==NULL){
    62.         perror("fopen");
    63.         return 0;
    64.     }
    65.  
    66.  
    67.     pthread_create(&tid,NULL,func,1);
    68.     pthread_create(&tid2,NULL,func2,2);
    69.  
    70.     while(1){    
    71.         sleep(1);
    72.     } 
    73.  
    74. }

     

  • 相关阅读:
    git工具 —— git clean 解析
    Pandas 数据排序
    黄金投资面对K线图有哪些好用的交易策略？
    系统编程 day13 (linux) 共享内存的知识 与函数的运用
    从新零售到社区团购，这中间发生了多少变化？
    python运行hhblits二进制命令的包装器类
    java计算机毕业设计springboot+vue园区管理系统
    消息队列Kafka、RocketMQ、RabbitMQ的优劣势比较
    Oracle 中排序碰到 null 值如何处理
    面试必备：聊聊分布式锁的多种实现！
  • 原文地址：https://blog.csdn.net/qq_52479948/article/details/127758365