Linux 多线程编程( POSIX )( 一 )-----> 基础篇

分手后的思念是犯贱 2022-06-13 03:13 242阅读 0赞

***ATTETION:附加代码地址：***   [ 点击打开链接][Link 1] http://blog.csdn.net/shanshanpt/article/details/7372708

所谓线程就是“一个进程内部的一个控制序列”。也就是一个进程内部的并行的基础！  
  
2.        Linux进程可以看成只有一个控制线程：  
            一个进程在同一时刻只做一件事情。有了多个控制线程以后，  
            在程序设计时可以把进程设计成在同一时刻能够做不止一件事，  
            每个线程处理各只独立的任务。即所谓并行！  
             
3.         线程的优点：  
                   （1）通过为每种事件类型的处理分配单独的线程，能够简化处理异步时间的代码。  
                   （2）多个线程可以自动共享相同的存储地址空间和文件描述符。  
                   （3）有些问题可以通过将其分解从而改善整个程序的吞吐量。  
                   （4）交互的程序可以通过使用多线程实现相应时间的改善，多线程可以把程序中  
                              处理用户输入输出的部分与其它部分分开。  
  
4.             线程的缺点：  
                  线程也有不足之处。编写多线程程序需要更全面更深入的思考。  
                  在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的  
                  变量而造成不良影响的可能性是很大的。调试一个多线程程序也  
                  比调试一个单线程程序困难得多。             
             
5.        线程标识：  
            我们已经知道进程有进程ID就是pid\_t，那么线程也是有自己的ID的pthread\_t数据类型！  
            注意：实现的时候可以用一个结构来代表pthread\_t数据类型，所以可以移植的操作系统  
                        不能把它作为整数处理。因此必须使用函数来对来对两个线程ID进行比较。  
             
            >>>>>:             
            关于比较线程ID函数：  
             \#include<pthread.h>  
             intpthread\_equal(pthread\_t tid1,pthread\_t tid2 );  
            注意：在线程中，线程ID的类型是pthread\_t类型，由于在Linux下线程采用POSIX标准，  
                          所以，在不同的系统下，pthread\_t的类型是不同的，比如在ubuntn下，是unsigned long类型，  
                          而在solaris系统中，是unsigned int类型。而在FreeBSD上才用的是结构题指针。  
                          所以不能直接使用==判读，而应该使用pthread\_equal来判断。  
            返回：非0值->相等；0->不等价         
                         
            >>>>>:  
            获取自身线程的id:  
             \#include<pthread.h>  
             pthread\_tpthread\_self(void);                         
            返回：调用线程的线程id             
            注意：在使用pthread\_create(pthread\_t \*thread\_id,NULL,void\* (\*fun) (void\*),void \* args);  
                          虽然第一个参数中已经保存了线程ID,但是，前提是主线程首先执行时，才能实现的，  
                          而如果不是，那么thread指向一个未初始化的变量。那么子线程想使用时，应该使用pthread\_self();             
                         
6.        线程的创建：  
             \#include<pthread.h>  
             intpthread\_create(pthread\_t \*restrict tidp,const pthread \_attr\_t\*restrict attr,void \*(\*start\_rtn)(void),void \*restrictarg);                   
             
             参数：  
            　　      第一个参数为指向线程标识符的指针。  
　　                  第二个参数用来设置线程属性。  
　　                  第三个参数是线程运行函数的起始地址。  
　　                  最后一个参数是运行函数的参数  
             
            返回成功时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于制定各种不同的  
            线程属性。新创建的线程从start\_rtn函数的地址开始运行，该函数只有一个万能指针参数arg，如  
            果需要向start\_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个  
            结构的地址作为arg的参数传入。               
                         
            注意：restrict修饰，  
            pthread\_join  
             运行：  
            在编译时注意加上-lpthread参数，以调用静态链接库。因为pthread并非Linux系统的默认库  
            if不加上就会报错:undefined reference to \`pthread\_create'。  
                         
7.         线程的终止与等待：  
            线程是依进程而存在的，当进程终止时，线程也就终止了。当然也有在不终止整个进程的情况下停止它的控制流。  
            <1>. 线程从启动例程中返回，返回值是线程的退出码。  
              <2>. 线程可以被同一进程中的其他线程取消。  
              <3>. 线程退出调用pthread\_exit.  
             \#include<pthread.h>  
             voidpthread\_exit( void \* rval\_ptr);             
             
             rval\_ptr是一个无类型指针，与传给启动例程的单个参数类似。  
            进程中的其他线程可以调用pthread\_join函数访问到这个指针。  
             
            pthread\_join:获得进程的终止状态。  
             
             intpthread\_join( pthread\_t thread, void \*\* rval\_ptr );  
            若成功返回0，否则返回错误编号。  
            调用pthread\_join进程将一直阻塞，直到指定的线程调用pthread\_exit,从启动例程中或者被取消。  
            如果线程只是从它的启动历程返回，rval\_ptr将包含返回码。  
             
8.        pthread\_detach：使线程进入分离状态  
             
             intpthread\_detach( pthread\_t tid );  
            若成功则返回0，否则返回错误编号。  
            注意：默认情况下是pthread\_join等待线程的结束，并可以获得结束时的状态！  
                        如果线程已经处于分离状态，线程的底层存储资源可以在线程终止时立即被收回。  
                        当线程被分离时，并不能用pthread\_join函数等待它的终止状态。  
             
9.        pthread\_cancel：取消同一进程中的其他线程(注意是取消其他线程)  
             
             intpthread\_cancel(pthread\_t tid);  
            若成功返回0，否则返回错误编号。  
            注意：pthread\_cancel并不等待线程终止，它仅仅提出请求。是否真的执行还看目标线程的  
                        state和type的设置了！  
             
10.   pthread\_cleanup\_push 和pthread\_cleanup\_pop：线程清理处理程序             
             
             voidpthread\_cleanup\_push( void ( \* rtn ) ( void \* )，void \*arg );  
             voidpthread\_cleanup\_pop( int exe );  
             参数：  
                        rtn：   处理程序入口地址  
                         arg：传递给处理函数的参数  
            线程可以安排它退出时需要调用的函数，这样的函数称为线程清理处理程序，线程可以建立多个清理处理程序。  
            注意：此处是使用栈保存的，所以是先进后处理原则！  
                        如果线程是通过从启动例程中返回而终止的，它的处理程序就不会调用。  
             
            !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  
            ATTENTION:  
                                    pthread\_cleanup\_push注册一个回调函数，如果你的线程在对应的pthread\_cleanup\_pop  
                                    之前异常退出(return是正常退出，其他是异常)，那么系统就会执行这个回调函数(回调函  
                                    数要做什么你自己决定)。但是如果在pthread\_cleanup\_pop之前没有异常退出，  
                                    pthread\_cleanup\_pop就把对应的回调函数取消了，  
             
             所以请注意：  
                        只有在“清理函数”的设置和取消之间有异常的退出，才会调用我们设置的“清理函数”。  
                        否则是不会输出的！  
                        一般的触发条件是：在之间有pthread\_exit(非正常退出)；或者有取消点时候！  
                         
             关于“取消点” (cancellation point ):  
                        例如执行下面代码：  
                                                       printf("sleep\\n");  
                                                        sleep(10);  
                                                         printf("wake \\n");  
            在sleep函数中，线程睡眠，结果收到cancel信号，这时候线程从sleep中醒来，但是线程不会立刻退出。  
            >>>>>:             
                        函数：pthread\_testcancel()：  
                        描述：函数在运行的线程中创建一个取消点，如果cancellation无效则此函数不起作用。  
                         
                        pthread的建议是：如果一个函数是阻塞的，那么你必须在这个函数前后建立 “ 取消点 ”, 比如：  
                                                       printf("sleep\\n");  
                                                      pthread\_testcancel();  
                                                        sleep(10);  
                                                        pthread\_testcancel();  
                                                         printf("wake \\n");  
                        在执行到pthread\_testcancel的位置时，线程才可能响应cancel退出进程。  
                         
                        对于一些函数来说本身就是有cancellation point 的，那么可以不管，但是大部分还是没有的，  
                        所以要使用pthread\_testcancel来设置一个取消点，那么也并不是对于所有的函数都是有效的，  
                        对于有延时的函数才是有效的，更清楚的说是有时间让pthread\_cancel响应才是OK的！  
                         
             附加：  
                        POSIX中的函数cancellation点的:  
                        pthread\_join  
                        pthread\_cond\_wait  
                        thread\_cond\_timewait  
                        pthread\_testcancel  
                        sem\_wait  
                        sigwait              都是cancellation点.  
                        下面的这些系统函数也是cancellation点:  
                         accept  
                         fcntl  
                         open  
                         read  
                         write  
                         lseek  
                         close  
                         send  
                        sendmsg  
                         sendto  
                        connect  
                         recv  
                        recvfrom  
                        recvmsg  
                         system  
                        tcdrain  
                         fsync  
                         msync  
                         pause  
                         wait  
                        waitpid  
                        nanosleep  
   
                        其它的一些函数如果调用了上面的函数, 那么, 它们也是cancellation点.  
                         intpthread\_setcancelstate (int STATE, int \*OLDSTATE);  
                        用于允许或禁止处理cancellation,  
                        STATE可以是:PTHREAD\_CANCEL\_ENABLE， PTHREAD\_CANCEL\_DISABLE  
  
                         intpthread\_setcanceltype (int TYPE, int \*OLDTYPE);  
                        设置如何处理cancellation, 异步的还是推迟的.  
                        TYPE可以是:PTHREAD\_CANCEL\_ASYNCHRONOUS， PTHREAD\_CANCEL\_DEFERRED  
                               
            >>>>                   
            摘录：http://blogt.chinaunix.net/space.php?uid=23381466&do=blog&id=58787  
  
                        什么是取消点（cancelation point）？  
  
                        资料中说，根据POSIX标准，pthread\_join()、pthread\_testcancel()、pthread\_cond\_wait()、  
                        pthread\_cond\_timedwait()、sem\_wait()、sigwait()等函数以及read()、write()等会引起阻塞  
                        的系统调用都是Cancelation-point。而其他pthread函数都不会引起 Cancelation动作。但  
                        是pthread\_cancel的手册页声称，由于LinuxThread库与C库结合得不好，因而目前C库函  
                         数都不是Cancelation-point；但CANCEL信号会使线程从阻塞的系统调用中退出，并置  
                        EINTR错误码，因此可以在需要作为Cancelation-point的系统调用前后调用pthread\_testcancel()，  
                        从而达到POSIX标准所要求的目标，即如下代码段：  
  
                        pthread\_testcancel();  
                         retcode =read(fd, buffer, length);  
                        pthread\_testcancel();  
  
                        我发现，对于C库函数来说，几乎可以使线程挂起的函数都会响应CANCEL信号，终止线程，  
                        包括sleep、delay等延时函数。             
                               
            !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  
             
11.             
             \#include<pthread.h>  
             intpthread\_setcancelstate( int state, int\* oldstate );  
  
             描述：  
            pthread\_setcancelstate()f函数设置线程取消状态为state，并且返回前一个取消点状态oldstate。  
            取消点有如下状态值：  
            PTHREAD\_CANCEL\_DISABLE：取消请求保持等待，默认值。  
            PTHREAD\_CANCEL\_ENABLE：取消请求依据取消类型执行；参考pthread\_setcanceltype()。  
             
             参数：  
             state：新取消状态。  
             oldstate：指向本函数所存储的原取消状态的指针。  
  
            ///       
       
             \#include<pthread.h>  
             intpthread\_setcanceltype( int type, int\* oldtype );  
  
             描述：  
            pthread\_setcanceltype()函数设置运行线程的取消类型为type，并且返回原取消类型与oldtype。  
             
             取消类型值：  
　　  PTHREAD\_CANCEL\_ASYNCHRONOUS：如果取消有效，新的或者是等待的取消请求会立即执行。  
　　  PTHREAD\_CANCEL\_DEFERRED：如果取消有效，在遇到下一个取消点之前，取消请求会保持等待，默认值。  
　　 注意if没有取消点，那么陷入死锁！！！  
            注意：标注POSIX和C库的调用不是异步取消安全地。  
  
             参数：  
             type：新取消类型  
             oldtype：指向该函数所存储的原取消类型的指针。  
  
       
12.     posix变量一次初始化问题：  
            >>>>>:  
            如果我们需要对一个posix变量静态的初始化，可使用的方法是用一个互斥量对该变量的初始话进行控制。  
            但有时候我们需要对该变量进行动态初始化，pthread\_once就会方便的多。  
             
            pthread\_once\_t   once\_control =PTHREAD\_ONCE\_INIT;  
             intpthread\_once( pthread\_once\_t \*once\_control, void( \* init\_routine )( void ) );  
            参数：once\_control                控制变量  
                        init\_routine                         初始化函数  
            若成功返回0，若失败返回错误编号。  
            pthread\_once\_t的变量是一个控制变量。控制变量必须使用PTHREAD\_ONCE\_INIT宏静态地初始化。  
             
             pthread\_once工作原理：  
                                                      pthread\_once函数首先检查控制变量，判断是否已经完成初始化，如果完成  
                                                      就简单地返回；否则，pthread\_once调用初始化函数，并且记录下初始化被完成。  
                                                      如果在一个线程初始时，另外的线程调用pthread\_once，则调用线程等待，直到  
                                                      那个现成完成初始话返回。  
               
13.      线程的私有数据：  
            在进程内的所有线程共享相同的地址空间，任何声明为静态或外部的变量，或在进程堆声明的变量，  
            都可以被进程所有的线程读写。那怎样才能使线程序拥有自己的私有数据呢。posix提供了一种方法，  
             创建 " 线程键"。  
             \#include<pthread.h>  
             intpthread\_key\_create(pthread\_key \*key,void(\*destructor)(void\*));  
             参数：  
            key                       私有数据键  
            destructor      清理函数参数  
             ifdestructor 不为空，那么系统将调用这个函数来释放绑定在这个键上的内存块。  
             
            这个函数常和函数pthread\_once一起使用，为了让这个键只被创建一次。  
             
14.       关于： "线程存储 "        
            现在有一全局变量，所有线程都可以使用它，改变它的值。而如果每个线程希望能单独拥有它，  
            那么就需要使用线程存储了。表面上看起来这是一个全局变量，所有线程都可以使用它，  
            而它的值在每一个线程中又是单独存储的。这就是线程存储的意义。  
  
             当然需要 “ 线程键”的参与！！！  
             
             intpthread\_setspecific(pthread\_key\_t key, const void\*value);      //!> 存储特殊值(即自己单独需要的值)  
             void\*pthread\_getspecific(pthread\_key\_tkey);                              //!> 取出所存储的值

[Link 1]: http://blog.csdn.net/shanshanpt/article/details/7372708