Linux 多线程编程( POSIX )( 一 ) ----> 代码区

矫情吗；* 2022-06-13 03:13 228阅读 0赞

***1.基础线程创建：***  
  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <pthread.h>  
  
void \* print\_id( void \* arg)

//!>这是线程的入口函数                                                 
\{  
       printf("TheCurrent process is: %d \\n",getpid());                                                      //!>当前进程ID       
       printf( "TheCurrent thread id : %d \\n", (unsigned)pthread\_self());      //!> 注意此处输出的子线程的ID  
\}  
  
int main( )  
\{  
      pthread\_t             t;  
       int                         t\_id;  
       
       t\_id =pthread\_create( &t, NULL, print\_id, NULL);            //!> 简单的创建线程  
       
       if( t\_id !=0 )                                    //!>注意创建成功返回0                                                 
       \{  
            printf("\\nCreate thread error...\\n");  
             exit(EXIT\_FAILURE );  
      \}   
       sleep( 1);  
      printf("\\nThe Current process is: %d \\n",getpid());                                     //!>当前进程ID             
       printf( "TheMain thread id : %d \\n", (unsigned)pthread\_self());      //!> 注意输出的MAIN线程的ID  
       return0;  
\}  
  
  
  
***2.测试线程的创建和退出***  
  
\#include <stdio.h>  
\#include <pthread.h>  
\#include <string.h>  
\#include <stdlib.h>  
  
void \* entrance\_1( void \* arg)                        //!> 第一个创建的线程的入口函数  
\{  
       printf( "thread 1 id == %d , run now ... \\n", ( unsigned )pthread\_self());  
       sleep( 3);  
       return ( (void \* ) 1 );  
\}  
  
void \* entrance\_2( void \* arg)                        //!> 第二个创建的线程的入口函数  
\{  
       printf( "thread 2 id == %d , run now ... \\n", ( unsigned )pthread\_self());  
       sleep( 3);  
       return ( (void \* ) 2 );  
\}  
  
int main( )  
\{  
      pthread\_t             t1 =-1;      //!> 最好是初始化：因为下面的pthread\_join是需要判断是否成功在输出的  
      pthread\_t             t2 =-1;  
      int                          tid1;  
      int                          tid2;  
      void        \*             ret;  
       
       tid1 =pthread\_create( &t1, NULL, entrance\_1, NULL);      //!> 简单的创建线程  
       tid2 =pthread\_create( &t2, NULL, entrance\_2, NULL);  
       
       if( tid1 !=0 || tid2 != 0)      //!>创建线程失败                               
       \{  
             printf("Create thread error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
       if( t1 != -1)                        //!> 也就是线程还没有结束  
       \{  
             if (pthread\_join( t1, &ret ) == 0)      //!> join success  
             \{  
                   printf( "thread 1 get the return of pthread\_join == %d \\n", 2 );/ )  
  \{  
        pthread\_mutex\_init( &mutex, NULL);            //!> 初始化为默认的互斥锁  
         
        printf("主函数：创建2个子线程...\\n");  
         
        create\_two\_thread();            //!> 创建2个线程  
         
        printf("主函数：等待线程完成任务...\\n");  
         
        wait\_two\_thread();            //!> 等待线程完成任务  
                                                  //!> 线程任务完成才可以执行下面代码  
        printf("线程任务完成...\\n");  
         
        printf("Num == %d \\n\\n", num);  
         
        return 0;  
  \}  
   
***4.双线程处理：冒泡排序算法***  
  
//           双线程处理冒泡排序(多线程也一样)  
//           实现从“小”--->“大”排序  
  
\#include <stdio.h>  
\#include <string.h>  
\#include <pthread.h>  
\#include <stdlib.h>  
  
int g\_arr\[\] = \{ 10, 23, 12, 34, 5, 29, 90, 9, 78, 44\};            //!> 全局的要排序的数组  
pthread\_t                        thread\[2\];                      //!> 两个线程  
pthread\_mutex\_t            mutex;                        //!> 互斥锁  
  
int                                      g\_i =0;                                    //!> 全局的剩余排列次数  
  
//!> 打印数组  
void print\_array()  
\{  
       int i;  
       for( i = 0;i < 10; i++ )  
       \{  
             printf( " %d", g\_arr\[i\] );  
       \}  
      printf("\\n");  
\}  
  
//!> 交换元素  
void swap\_elem( int \* a, int \* b )  
\{  
       inttemp;  
       temp =\*a;  
       \*a =\*b;  
       \*b =temp;  
\}  
  
//!> 线程1入口函数  
void \* entrance\_1( void \* arg )  
\{  
       int j;  
       for( g\_i =0; g\_i < 10; g\_i++)      //!> 外层循环  
       \{  
            pthread\_mutex\_lock( &mutex);            //!> 加锁  
             
             printf("线程1后台执行排序...\\n" );  
             
             for( j = 0;j < ( 10 - g\_i - 1 ); j++)      //!> 内层循环  
             \{  
                   if( g\_arr\[j\]> g\_arr\[j+1\] )  
                   \{  
                         swap\_elem(&g\_arr\[j\], &g\_arr\[j+1\] );  
                   \}  
             \}  
             
            pthread\_mutex\_unlock( &mutex);      //!> 解锁  
             
             sleep( 1);  
       \}  
\}  
  
//!> 线程2入口函数  
void \* entrance\_2( void \* arg )  
\{  
       int j;  
       for( g\_i =0; g\_i < 10; g\_i++)      //!> 外层循环  
       \{  
            pthread\_mutex\_lock( &mutex);            //!> 加锁  
             
             printf("线程2后台执行排序...\\n" );  
                   
             for( j = 0;j < ( 10 - g\_i - 1 ); j++)      //!> 内层循环  
             \{  
                   if( g\_arr\[j\]> g\_arr\[j+1\] )  
                   \{  
                         swap\_elem(&g\_arr\[j\], &g\_arr\[j+1\] );  
                   \}  
             \}  
       
            pthread\_mutex\_unlock( &mutex);      //!> 解锁  
  
             sleep( 2);       
       \}  
\}  
  
//!> 创建2个线程  
void create\_two\_thread()  
\{  
       memset(&thread, 0, sizeof( thread ));                  //!> 初始化为0(作为下面的判断进程是否创建OK依据)  
       
       if( (pthread\_create( &thread\[0\], NULL, entrance\_1, NULL) ) == 0 )  
       \{  
            printf("线程1创建OK ...\\n");  
       \}  
       else  
       \{  
            printf("线程1创建Error ...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
       if( (pthread\_create( &thread\[1\], NULL, entrance\_2, NULL) ) == 0 )  
       \{  
            printf("线程2创建OK ...\\n");  
       \}  
       else  
       \{  
            printf("线程2创建Error ...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
\}  
  
//!> 线程执行与等待  
void do\_and\_wait()  
\{  
       if(thread\[0\] != 0 )//!>由于在create\_two\_thread中初始化=0，if床架ok，那么不可能还是0  
       \{  
            pthread\_join( thread\[0\], NULL);      //!> 等待线程1结束,不结束不执行下面代码  
            printf("线程1执行结束退出...\\n");  
       \}  
       else  
       \{  
            printf("线程1创建Error...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
       if(thread\[1\] != 0 )  
       \{  
            pthread\_join( thread\[1\], NULL);      //!> 等待线程1结束,不结束不执行下面代码  
            printf("线程2执行结束退出...\\n");  
       \}  
       else  
       \{  
            printf("线程2创建Error...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
\}  
  
int main( )  
\{  
      printf("主函数：下面创建2个线程共同处理冒泡排序...\\n");  
       
      pthread\_mutex\_init( &mutex, NULL );  
       
      print\_array();                        //!> 打印排序前的结果  
       
      create\_two\_thread();            //!> 创建线程  
      do\_and\_wait();                  //!> 执行线程and等待  
       
       printf("排序完成：\\n" );  
  
      print\_array();                        //!> 打印排序后的结果  
             
       return0;  
\}  
  
***5.线程清理处理程序***  
  
//           线程清理处理程序TEST  
  
\#include <stdlib.h>  
\#include <stdio.h>  
\#include <pthread.h>  
  
void clean(void \*arg)  
\{  
       printf("清理:%s \\n", (char \*)arg);  
\}  
  
void \* entrance( void \* arg )  
\{  
      printf("线程开始...\\n");  
       
      pthread\_cleanup\_push( clean, "线程处理程序1" );  
      pthread\_cleanup\_push( clean, "线程处理程序2" );  
       
      printf("pthread clean 完成...\\n");  
       
      sleep(3);  
       
      pthread\_exit((void\*)0);            //!> 我们知道：清理函数只有在异常退出时候才会做一些清理工作  
                                                                      //!> 所以此处的退出是异常退出来测试的！  
       
      pthread\_cleanup\_pop(0);       
      pthread\_cleanup\_pop(0);       
       
       
       
\}  
  
int main( )  
\{  
       pthread\_t       tid;  
      void        \*        ret = NULL;  
       
       if( (pthread\_create( &tid, NULL, entrance, (void \*)1 ) )!= 0 )  
       \{  
            printf("创建线程失败...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
      pthread\_join( tid, &ret);             
       
       if( ret)                                          //!> 注意此处相当于是抛出异常  
      \{                                                //!> 避免子线程的异常退出造成的空指针情况  
             printf("结束：code == %d\\n", \*( ( int \* ) ret) );  
       \}  
       
       return0;  
\}  
  
/  
//      DEMO——2  
  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <pthread.h>  
  
void clean( void \* arg )  
\{  
      printf("清理函数执行...\\n");  
\}  
  
void \* entrance( void \* arg )  
\{  
       intold\_type, old\_state;  
       int i =0;  
       
      pthread\_cleanup\_push( clean, NULL);      //!> 设置清理函数  
      printf("下面设置对本线程的“取消”无效\\n");  
      pthread\_setcancelstate( PTHREAD\_CANCEL\_DISABLE,&old\_state );  
                                                                        //!> 设置对本线程的“取消”无效  
      pthread\_setcanceltype(PTHREAD\_CANCEL\_ASYNCHRONOUS,&old\_type);      //>>>>>>>>>>>目标句1  
       
       while( 1)  
       \{  
             \++i;  
            printf("子线程runing...\\n");  
             sleep( 2);  
             if( 5 == i)  
             \{  
                  printf("下面取消设置对本线程的“取消”无效\\n");  
                  pthread\_setcancelstate(PTHREAD\_CANCEL\_ENABLE,&old\_state);  
             \}  
       \}  
       
      pthread\_cleanup\_pop( 0 );  
\}  
  
int main( int argc, char \*\* argv )  
\{  
      pthread\_t      tid;  
       int                      res;  
       void\*                ret;  
       
      pthread\_create( &tid, NULL, entrance, NULL );  
       sleep( 2);  
      printf("请求子线程退出...\\n");  
      pthread\_cancel( tid);                  //!> 请求子线程退出  
       
       res =pthread\_join( tid, &ret);      //!> 等待子线程退出  
       
       if( ret !=PTHREAD\_CANCELED)      //!> 非安全退出  
       \{  
            printf("pthread\_join 失败...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       else  
       \{  
            printf("Success..");  
       \}  
             
       exit(EXIT\_SUCCESS);       
\}  
  
  
       分析：  
            没有加上“目标句”的结果是：  
                                                            下面设置对本线程的“取消”无效  
                                                            子线程runing...  
                                                            请求子线程退出...  
                                                            子线程runing...  
                                                            子线程runing...  
                                                            子线程runing...  
                                                            子线程runing...  
                                                            下面取消设置对本线程的“取消”无效  
                                                            子线程runing...                                    //!> 比下面多的  
                                                            清理函数执行...  
                                                            Success..                                                //!> 与下面不一样的  
                                                             
          加上后：  
                                                            下面设置对本线程的“取消”无效  
                                                            子线程runing...  
                                                            请求子线程退出...  
                                                            子线程runing...  
                                                            子线程runing...  
                                                            子线程runing...  
                                                            子线程runing...  
                                                            下面取消设置对本线程的“取消”无效  
                                                            清理函数执行...  
                                                             pthread\_join失败...                              //!> 与上面不一样的  
                                                             
            这句的作用是将取消类型设置为PTHREAD\_CANCEL\_ASYNCHRONOUS，即取消请求会被立即响应                                                       
          那么就不会再次进入等待下一个“取消点”再进行取消！！！  
       
          注意：if在while中没有sleep，那么程序会无限run，我们知道sleep是相当于是释放一下线程，那么此时的主线程中的cancel信号又被接收到，那么if本函数可以响应了，那么就cancle了，if将sleep去掉，那么死循环！再次解释：所谓pthread\_cancel仅仅是请求某个线程退出，那么究竟是不是退出还要看state和type的设置！                               
  
  
  
***6. pthread\_once工作原理code***  
  
  
//            pthread\_once函数使用  
  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <pthread.h>  
  
pthread\_once\_t             once =PTHREAD\_ONCE\_INIT;      //!> once宏赋值  
  
//!> 初始化执行函数  
void once\_init( void )  
\{  
      printf("初始化成功！ 我的ID == %d\\n", (unsigned)pthread\_self());  
\}  
  
//!> 线程入口函数  
void \* entrance( void \* arg )  
\{       
      printf("子线程：ID == %d \\n", (unsigned)pthread\_self());  
      //!> once =PTHREAD\_ONCE\_INIT;            //!> 测试使用(下面的要求)  
      pthread\_once( &once, once\_init);            //!> 此处也有初始化  
\}  
  
//!> main函数  
int main( int argc, char \* argv\[\] )  
\{  
      pthread\_t             pid;  
       
      pthread\_create( &pid, NULL, entrance, NULL );  
  
      printf("主函数ID == %d \\n", (unsigned)pthread\_self());  
       
//!>      pthread\_join( pid, NULL);                  //!> 分析点  
       
      pthread\_once( &once, once\_init);      //!> 调用一次初始化函数  
       
      pthread\_join( pid, NULL );  
       
       return0;  
\}  
  
             ifpthread\_join是在主函数初始化后面，那么就是主函数初始化的  
             结果是： 主函数ID== 441960192  
                                    初始化成功！ 我的ID == 441960192  
                                  子线程：ID == 433944320  
            显而易见是主函数初始化的！  
             
             ifpthread\_join是在之前，那么就是要等待子函数执行ok后才执行自己的下面代码  
            但是此时已经初始化ok了，所以不在初始化！  
             结果是：主函数ID ==210818816  
                                  子线程：ID == 202802944  
                                  初始化成功！ 我的ID == 202802944  
            显然是子函数执行的初始化！  
  
            本质：    其实就是操作once变量而已，与互斥变量的本质是一样的！！！  
                                    我们可以这样测试在entrance中加入once = PTHREAD\_ONCE\_INIT;  
             结果是：主函数ID ==1590228736  
                                  初始化成功！ 我的ID == 1590228736  
                                  子线程：ID == 1582212864  
                                  初始化成功！ 我的ID == 1582212864  
             
            感兴趣的可以使用pthread\_mutex\_t 的互斥变量处理，效果一样！  
            还有最最简单的就是bool值处理！此处不建议！  
  
***7.pthread\_key\_create线程键 与线程存储***  
  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <pthread.h>  
  
pthread\_once\_t             once =PTHREAD\_ONCE\_INIT;  
pthread\_key\_t            key;                  //!> 键值  
       
int                                      g\_val =10;      //!> 传说中的独享值，呵呵  
  
void once\_init\_key()  
\{       
       if(pthread\_key\_create( &key, NULL ) == 0)      //!> 创建线程键值  
      \{                                                                              //!>  
            printf("创建线程键OK ...\\n");  
       \}  
\}  
  
void \* entrance( void \* arg )  
\{  
       int \*val;  
      printf("子线程：ID == %d \\n", (unsigned)pthread\_self());  
       
      pthread\_setspecific( key, &g\_val);                        //!> 将 g\_val 作为一个每个进程的独享值  
       
       val = ( int\* )pthread\_getspecific( key);            //!> 取出那个值  
                                                                                    //!> 此后对于这些量都有自己的处理方式，  
                                                                                    //!>名称相同但是内容不同！！！       
                                                                                    //!> 对于文件的处理是最好的！！！  
       printf("ID== %d, Value == %d\\n",   (unsigned)pthread\_self(),\*val);  
\}  
  
  
int main( )  
\{  
      pthread\_t             tid,tid2;  
      void        \*         ret1;  
      void        \*        ret2;  
       
       if(pthread\_create( &tid, NULL, entrance, NULL ) != 0)                  //!> 线程1  
       \{  
            printf("创建线程1失败...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
       if(pthread\_create( &tid2, NULL, entrance, NULL ) != 0)                  //!> 线程2  
       \{  
            printf("创建线程2失败...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
                   
      printf("主函数：ID == %d \\n", (unsigned)pthread\_self());  
             
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>       
       
      pthread\_once( &once, once\_init\_key);      //!> 创建一个键值  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
       
      printf("下面等待子线程执行ok... \\n");  
       
      pthread\_join( tid, &ret1);                              //!> 等待线程( 必不可少 )  
      pthread\_join( tid2, &ret2 );  
       
       return0;  
\}  
  
结果：  
       主函数：ID ==1588877056  
       创建线程键OK...  
       子线程：ID ==1580861184  
       ID ==1580861184, Value == 10  
      下面等待子线程执行ok...  
       子线程：ID ==1572468480  
       ID ==1572468480, Value == 10