LinuxC----线程总结

Dear 丶 2022-05-16 21:18 249阅读 0赞

## 一.线程和进程的关系 ##

为什么要引入线程?

> CPU的执行速度过快，只有寄存器仅仅可以追上，RAM和别的设备更是难以追上,而进程和线程只不过是对应的CPU时间段的描述.  
> 进程是cpu资源分配的最小单位，线程是cpu调度的最小单位

线程和进程的联系有

> (1)进程是资源的分配和调度的一个独立单元，线程是CPU调度的基本单元  
> (2)同一个进程中包括多个线程,所有的线程共享进程的地址空间，可以在执行过程中节省时间  
> (3)系统调度时，切换的速度十分快，主要是因为进程地址空间独立而进程的线程独享地址空间  
> (5)线程不能独立存在，必须依附于进程  
> (6)进程所使用的内存地址可以限定使用通过信号来控制

线程的优点:

> (1)可以提高应用程序的响应速度  
> (2)可以提高多处理器的效率  
> (3)可以改善程序的结构

线程可以独立有自己的数据信息

> (1)通过使用互斥锁来保存  
> (2)线程号  
> (3)堆栈  
> (4)信号掩码  
> (5)优先级  
> (6)线程私有的存储空间

## 二.创建线程 ##

1.pthread\_create - 线程创建  
头文件：

#include < pthread.h > int pthread_create
    (pthread_t * thread , const pthread_attr_t * attr , void *(* start_routine )(void*), void * arg );
    
     #include < pthread.h > int pthread_create(pthread_t * thread , const pthread_attr_t * attr , void *(* start_routine )(void*), void * arg );

pthread\_create（）函数用于在进程内创建具有由attr指定的属性的新线程。 如果attr为NULL，则使用默认属性。 如果稍后修改attr指定的属性，则不会影响线程的属性。 成功完成后， pthread\_create（）将创建的线程的ID存储在线程引用的位置。

--------------------

创建线程执行start\_routine ， arg作为其唯一参数。 如果start\_routine返回，则效果就像是使用start\_routine的返回值作为退出状态对pthread\_exit（）进行隐式调用。 请注意，最初调用main（）的线程与此不同。 当它从main（）返回时，效果就好像使用main（）的返回值作为退出状态对exit（）进行了隐式调用。

--------------------

新线程的信号状态初始化如下：

> 信号掩码继承自创建线程。  
> 待处理新线程的信号集为空。  
> 如果pthread\_create（）失败，则不会创建新线程，并且未定义线程引用的位置的内容。

返回值  
如果成功，则pthread\_create（）函数返回零。 否则，返回错误号以指示错误。  
错误  
如果出现以下情况， pthread\_create（）函数将失败：  
\[EAGAIN\]  
系统缺少创建另一个线程所需的资源，或者会超出系统对进程PTHREAD\_THREADS\_MAX中线程总数的限制。  
\[EINVAL\]  
attr指定的值无效。  
\[EPERM\]  
调用者没有适当的权限来设置所需的调度参数或调度策略。  
pthread\_create（）函数不会返回\[EINTR\]的错误代码。

--------------------

创建线程的其他系统的函数

## <table>   <thead>    <tr>     <th>函数</th>     <th>说明</th>    </tr>   </thead>   <tbody>    <tr>     <td>pthread_t pthreadself(void)</td>     <td>获取本线程的线程ID</td>    </tr>    <tr>     <td>int pthread_equal(pthread_t thread1,pthread_t thread2)</td>     <td>判断两个进程ID是不是指向同一进程</td>    </tr>    <tr>     <td>int pthread_once(pthread_once_t * once_control,void(*init_routine)(void)</td>     <td>用来保证线程函数在进程中只执行一次</td>    </tr>   </tbody>  </table> ##

如何正确的创建线程?

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<pthread.h>//创建线程所需的头文件
    
    int * thread(void * arg)//线程所调用的函数
    {
         pthread_t newthid;
    
         newthid = pthread_self();
         printf("this is a new thread , thread  ID = %u \n",newthid);
         return NULL;
    }
    
    int main(void)
    {
        pthread_t thid;
        printf("main thread , ID is %u \n",pthread_self());///打印主线程的ID
        if(pthread_create(&thid,NULL,(void *)thread,NULL)!=0)
        {
            exit(1);
        }
        sleep(1);//让主线程等待子线程结束，不然无法打印相应的值
        return 0;
    }

注：在这里sleep是必要的，如果不是用sleep的话，主线程也就是main函数会直接退出，主线程的退出引起了进程的结束，从而导致了子线程的结束，看不到第二次的printf的值

## 三.线程属性 ##

1.pthread\_attr\_t详解

typedef struct
    {
       int detachstatte;
       int schedpolicy;
       struct sched_param schedparam;
       int inheritsched;
       int scope;
       size_t guardsize;
       int stackaddr_set;
       void * stackaddr;
       size_t stacksize;
    }pthread_attr_t;

*  detachstata 表示新创建的线程是不是与进程中的其他的线程脱离同步，它的缺省属性是PTHREAD\_CREATE\_JOINABLE  
    可以使用pthread\_detach()来设置,设置pthread\_detach()之后线程运行结束后会自动释放系统状态
 *  schedpolicy表示新线程的调度策略,主要有SCHED\_other(正常，非实时),(SCHED\_RR)表示轮转法,SCHED\_FIFO(实时，先入先出)
 *  schedparam，一个struct sched\_param结构，目前仅有一个sched\_priority整型变量表示线程的运行优先级。这个参数仅当调度策略为实时（即SCHED\_RR或SCHED\_FIFO）时才有效，并可以在运行时通过pthread\_setschedparam()函数来改变，缺省为0。
 *  inheritsched，有两种值可供选择：PTHREAD\_EXPLICIT\_SCHED和PTHREAD\_INHERIT\_SCHED，前者表示新线程使用显式指定调度策略和调度参数（即attr中的值），而后者表示继承调用者线程的值。缺省为PTHREAD\_EXPLICIT\_SCHED。
 *  scope，表示线程间竞争CPU的范围，也就是说线程优先级的有效范围。POSIX的标准中定义了两个值：PTHREAD\_SCOPE\_SYSTEM和PTHREAD\_SCOPE\_PROCESS，前者表示与系统中所有线程一起竞争CPU时间，后者表示仅与同进程中的线程竞争CPU。目前LinuxThreads仅实现了PTHREAD\_SCOPE\_SYSTEM一值。
 *  guardsize: 警戒堆栈的大小
 *  stackaddr\_set: 堆栈地址集
 *  stackaddr : 堆栈的地址
 *  stacksize :堆栈大小

--------------------

线程终止:  
Linux下有三种线程终止的方式:  
(1)通过return 从线程函数返回  
(2) 通过调用函数pthread\_exit()让线程退出  
(3)甲线程可以让乙线程使用pthread\_cancel()函数从而让它退出  
pthread\_exit在pthread.h中声明

#include < pthread.h>
     void pthread_exit(void * retval)

在主线程中,如果从main函数返回或者是调用了exit函数退出主线程,整个进程将终止,另外一种情况是如果主线程调用了pthread\_t函数，仅仅是主函数消亡，进程并不会结束，直到所有的线程结束，进程才会结束

--------------------

那么线程终止之后的资源释放的问题该如何处理?

系统为我们提供了一对函数,pthread\_cleanup\_push(),pthread\_cleanup\_pop()用于自动释放资源  
他们是以宏的方式进行提供的，也就是说明了  
在push和pop之间不能使用return 函数,不然将不会清理完毕  
cleanup\_push ()把东西压入栈中，pop把栈中的东西弹出

#  define pthread_cleanup_push(routine, arg) \
      do {                                        \
        __pthread_cleanup_class __clframe (routine, arg)
    
    /* Remove a cleanup handler installed by the matching pthread_cleanup_push.
       If EXECUTE is non-zero, the handler function is called. */
    #  define pthread_cleanup_pop(execute) \
        __clframe.__setdoit (execute);                        \
      } while (0)

--------------------

线程的同步问题:  
一般来说，进程中的各个线程的运行是相互独立的，线程的终结并不会相互通知，也不会影响其他线程，终结的线程所占用的资源不会随着线程的结束而归还系统，有些资源得不到释放  
和进程中类似的是进程中有wait函数,线程中有pthread\_join函数

int pthread_join (pthread_t __th, void **__thread_return)

需要注意的是一个线程只允许一个线程使用pthread\_join()等待它的终止，而且被等待的线程应该处于可join状态，即非DETACHED状态，DETACHED状态是指堆某个线程执行了pthread\_deatch()函数所处的状态，处于DETACHED状态的线程无法由pthread\_join（）同步  
一个可”join”的线程所占用的内存仅仅当由线程执行了pthread\_join之后

--------------------

## 四.私有数据及线程同步 ##

线程的私有数据是通过一键多值来实行的，一个键对应多个值

#include<pthread.h>
     int pthread_key_create (pthread_key_t *__key,
                       void (*__destr_function) (void *))
         __THROW __nonnull ((1));
    
    /* Destroy KEY.  */
     int pthread_key_delete (pthread_key_t __key) __THROW;
    
    /* Return current value of the thread-specific data slot identified by KEY.  */
     void *pthread_getspecific (pthread_key_t __key) __THROW;
    
    /* Store POINTER in the thread-specific data slot identified by KEY. */
     int pthread_setspecific (pthread_key_t __key,
                    const void *__pointer) __THROW ;

*  pthread\_key\_create: 从LInux中的TSD中分配一项，将值给予key供以后使用,key表示的是指向键值的指针，第二个参数为一个函数指针,如果指针不为空，在线程退出之后将以key所关联的数据为参数调用destr\_function(),释放缓存区
 *  pthread\_setspecific:通过将pointer于key相关联,指定一个新数据，会同时释放旧数据
 *  pthread\_getspecific: 通过函数的得到于key相关联的数据
 *  pthread\_key\_delete :函数用来删除一个键，删除后，键所占用的内存会被释放，但是线程数据的释放必须在释放键之前完成

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<pthread.h>
    
    pthread_key_t key;
    
    void * thread2(void * arg)
    {
        int tsd=5;
        printf("thread %d is running\n",pthread_self());//获取pid
        pthread_setspecific(key,(int *)tsd);//给予了一个特殊的建位
        printf("thread %d returns %d\n",pthread_self(),pthread_getspecific(key));//getspecific函数获取私有数据的键值
    }
    void * thread1(void * arg)
    {
        int tsd=0;
        pthread_t thid2;
    
        printf("thread %d is running\n",pthread_self());//获取pid
        pthread_setspecific(key,(int *)tsd);//给予特殊的建位这个建位为0
        pthread_create (&thid2,NULL,thread2,NULL);
        sleep(1);
        printf("thread %d returns %d\n",pthread_self(),pthread_getspecific(key));
    }
    
    int main(void)
    {
       pthread_t thid1;
       printf("main thread begins runnning \n");
       pthread_key_create (&key,NULL);//创建一个建值，第二个参数如果不为空的话，线程退出之后
       pthread_create (&thid1,NULL,thread1,NULL);//创建一个线程，同时调用thread1线程函数
       sleep(3);
       pthread_key_delete (key);
       printf("main thread exit\n");
       return 0;
    }

2.互斥锁的使用

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pthread_mutex_init 函数</td> 
   <td>初始化一个互斥锁</td> 
  </tr> 
  <tr> 
   <td>pthread_mutex_destory 函数</td> 
   <td>注销一个互斥锁</td> 
  </tr> 
  <tr> 
   <td>pthread_mutex_lock 函数</td> 
   <td>加锁，如果不成功，阻塞等待</td> 
  </tr> 
  <tr> 
   <td>pthread_mutex_unlock 函数</td> 
   <td>解锁</td> 
  </tr> 
  <tr> 
   <td>pthread_mutex_trylock 函数</td> 
   <td>测试加锁，如果不成功就返回</td> 
  </tr> 
 </tbody> 
</table>

互斥锁的初始化  
“静态赋值法: pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER；  
通过函数来进行初始化操作

--------------------

int pthread\_mutex\_intit (pthread\_mutex\_t \* mutex, const pthread\_mutexattr\_t \*mutexattr);  
加锁的同时，如果mutex已经被锁主，当前尝试加锁的线程就会阻塞，直到互斥锁被其他线程释放，当pthread\_mutex\_lock返回的时候，说明，互斥锁已经被当前线程成功的加锁，pthread\_mutex\_trylock函数不同，会返回一个EBUSY

int pthread_mutex_unlock(pthread_mutex_t * mutex);

解锁必须满足两个条件，一是互斥锁必须处于加锁状态，二是线程必须是给互斥锁加锁的线程

当一个互斥锁使用完毕之后，必须进行清除,使用函数pthread-mutex\_destroy函数

int pthread_mutex_destory(pthread_mutex_t * mutex);

清除的时候要求当前必须处于开放状态，如果锁定状态，返回EBUSY

3条件变量  
条件变量是利用线程间共享的全局变量进行同步的一种机制  
主要包括两个动作：一是等待使用资源的线程等待”条件变量被设置真”,另一个是一个线程在使用完资源后，”设置条件为真”

条件变量可以让我们睡眠到某种状态的出现  
pthread\_cond\_wait与pthread\_mutex配合使用

--------------------

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pthread-cond_init 函数</td> 
   <td>初始化变量</td> 
  </tr> 
  <tr> 
   <td>pthread_cond_wait 函数</td> 
   <td>基于条件变量阻塞，无条件等待</td> 
  </tr> 
  <tr> 
   <td>pthread-cond_timedwait 函数</td> 
   <td>阻塞直到指定时间发生</td> 
  </tr> 
  <tr> 
   <td>pthread_cond_singal 函数</td> 
   <td>接触特定线程的阻塞，存在多个等待线程按入队顺序激活其中一个</td> 
  </tr> 
 </tbody> 
</table>

条件变量的初始化方式也有两种  
“静态赋值法: pthread\_cond\_t cond = PTHREAD\_COND\_INITIALIZER；  
通过函数来进行初始化操作

int pthread\_cond\_ntit (pthread\_cond\_t \* cond, pthread\_condattr\_t \* cond\_attr);

--------------------

等待条件成立的函数有两种:  
int pthread\_cond\_wait (pthread\_cond\_t \*\_\_restrict \_\_cond,  
pthread\_mutex\_t \*\_\_restrict \_\_mutex)

int pthread\_cond\_timedwait (pthread\_cond\_t \*\_\_restrict \_\_cond,  
pthread\_mutex\_t \*\_\_restrict \_\_mutex,  
const struct timespec \*\_\_restrict \_\_abstime)

--------------------

pthread\_cond\_wait中的mutex必须为适应锁或者互斥锁  
pthread\_cont\_wait返回自动对互斥锁重新进行加锁  
销毁条件变量释放空间，必须在没有条件变量的等待的基础之上

pthread\_cond\_wait函数释放由mutex指向的互斥锁，同时让当前进程关于cond指向的条件变量阻塞，直到条件被信号唤醒

#include<stdio.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<pthread.h>
    #include<string.h>
    
    pthread_mutex_t mutex;//互斥锁
    pthread_cond_t cond;//操作的条件变量
    
    void * thread1(void * arg)
    {
        pthread_cleanup_push (pthread_mutex_unlock,&mutex);//用于自动释放资源，pthread_clean_up_push()的调用点和pthread_clean_pop()的调用点
    
        while(1)
        {
            printf("thread1 is running\n");
            pthread_mutex_lock (&mutex);//建立互斥锁,
            //无论那种类型的锁，使用pthread_mutex_lock加锁时候，如果mutex被锁住，目前尝试加锁的线程就会阻塞,
            //其中一个必须等待解索，等待队列中的第一个线程将会获得互斥锁
            pthread_cond_wait (&cond,&mutex);//释放mutex指向的互斥锁，同时让当前线程关于cond指向的条件变量阻塞，直到条件被信号唤醒
            //线程改变条件变量的值，条件变量会获得一个信号，使得等待条件变量的线程退出阻塞状态
            printf ("thread1 applied the condition\n");
            pthread_mutex_unlock(&mutex);//将互斥锁解锁
            sleep(4);
        }
        pthread_cleanup_pop(0);
    }
    
    void *thread2(void * arg)
    {
           while(1)
           {
               printf("thread2 is running\n");
               pthread_mutex_lock(&mutex);//实行互斥锁
               pthread_cond_wait(&cond,&mutex);//防止多个线程请求
               //基于条件等待，释放互斥锁
               printf("thread2 applied the condition\n");
               pthread_mutex_unlock(&mutex);//
               sleep(1);
           }
    }
    
    int main(void)
    {
         pthread_t tid1,tid2;
    
         printf("condition variable study!\n");
         pthread_mutex_init(&mutex,NULL);
         pthread_cond_init(&cond,NULL);
         pthread_create(&tid1,NULL,(void *)thread1,NULL);
         pthread_create(&tid2,NULL,(void *)thread2,NULL);
    
        do{
            pthread_cond_signal(&cond);
        }while(1);
        sleep(10);
        pthread_exit(0);
    }