Linux下线程

什么是线程

在一个程序中的多个执行路线就叫做线程（thread）。更准确的定义是：线程是一个进程内部的一个控制序列。

线程的优点和缺点

在某些环境下，创建新线程要比创建新进程有更明显的优势。新线程的创建代价要比新进程小得多。线程的优点如下：

（1）线程间的数据共享比进程间容易得多。有时，让程序看起来好像是在同时做两件事情是很有用的。一个经典的例子是，在编辑文档的同时对文档中的单词个数进行实时统计。一个线程负责处理用户的输入并执行文本编辑工作，另一个线程在可以看到相同的文档内容的同时也不断刷新单词计数的变量。第一个线程通过这个共享的计数变量让用户随时了解自己的工作进展情况。另一个例子是一个多线程的数据库服务器，这时一种明显的单进程服务多用户的情况，它会在响应一些请求的同时阻塞另外一些请求，使之等待磁盘操作，从而改善整体上的数据吞吐量，对于数据库服务器来说，这个明显的多任务工作如果用多进程的方式来完成将很难做到高效，因为各个不同的进程必须紧密合作才能满足枷锁和数据一致性方面的要求，而且用多线程来完成就比用多进程要容易得多。

（2）多线程可以改善程序执行性能。一个混杂着输入、计算和输出的应用程序，可以将这几个部分分离为3个线程来执行，从而改善程序执行的性能。当输入或输出线程等待连接时，另外一个线程可以继续执行。因此，如果一个进程在任一时刻最多只能做一件事情的话，线程可以让它在等待连接之类的事情的同时做一些其他有用的事情。一个需要同时处理多个网络连接的服务器应用程序也是一个天生适用于应用多线程的例子。

（3）系统资源消耗低。一般而言，线程之间的切换需要操作系统做的工作要比进程之间的切换少得多，因此多个线程对资源的需求要远小于多个进程。如果一个程序在逻辑上需要有多个执行线程，那么在单处理器系统上把它运行为一个多线程程序才更符合实际情况虽然如此，编写一个多线程程序的设计困难较大。

线程也有一些缺点：

（1）编写多线程程序要非常仔细地设计。在多线程程序中，因时序上的细微偏差或无意造成的变量共享二引发错误的可能性是很大的。

（2）对多线程程序的调试比对单线程程序的调试要难得多，因为线程之间的交互非常难于控制。

（3）将大量计算分成两个部分，并把这两个部分作为两个不同的线程来运行的程序在一台单处理器机器上并不一定运行得更快，除非计算确实允许它的不同部分可以被同时计算，而且运行它的机器拥有多个处理器核来支持真正的多处理。

接下来使用一个简单的多线程的例子来说明以下各个函数的使用：

#include <stdio.h>
#include <pthread.h>
static int run = 1;     //运行状态参数
static int retvalue;    //线程返回值
//线程处理函数
void *start_routine(void *arg)
{
    int *running = arg;         //获取运行状态指针
    printf("子线程初始化完毕，传入参数为：%d\n",*running);      //打印
    while(*running)
    {
        printf("子线程正在运行......\n");
        sleep(1);
    }
    printf("子线程退出！\n");
    //设置退出值
    retvalue = 8;
    //线程退出并设置退出值
    pthread_exit((void *)&retvalue);
}
int main()
{
    pthread_t pt;
    int ret = -1;
    int times = 3;
    int i = 0;
    int *ret_join = NULL;
    //创建线程
    ret = pthread_create(&pt,NULL,(void *)start_routine,&run);
    //创建失败
    if(ret != 0)
    {
        printf("创建线程失败！\n");
        return 1;
    }
    sleep(1);
    for(;i < times;i++)
    {
        printf("主线程打印\n");
        sleep(1);
    }
    run = 0;
    //等待线程退出
    pthread_join(pt,(void *)&ret_join);
    printf("线程的返回值为:%d\n",*ret_join);
    return 0;
}

上面的THREAD_1.c在一个进程中调用函数pthread_create()建立了一个子线程。主线程在建立了子线程之后打印"主线程打印......"，子线程建立成功后打印"子线程正在运行......"。当标志参数running不为0的时候，子线程会一直打印上述消息。主线程在打印上述的"主线程打印......"3次后，设置标志参数为0，然后调用pthread_join()函数等待线程退出。子线程处理函数start_routine()在running为0之后设置推出之为8，调用函数pthread_exit()函数退出，然后主线程的pthread_join()会返回，程序结束。执行结果如下：

pthread_create()函数：线程创建

在使用pthread_create()函数创建线程时，传入的参数有线程属性、线程函数、线程函数变量，用于生成一个某种特性的线程，线程中执行线程函数。

//函数原型
int pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);

参数列表：

thread：用于标示一个线程，它是一个pthread_t类型的变量，在头文件pthreadtypes.h中定义。

attr：用于设置线程的属性。上述例子中为NULL。

start_routine：用于表示当线程的资源分配成功后，线程中所运行的单元，通常为用户自己编写的一个函数，上述例子中为start_routine()函数。

arg：线程函数运行时传入的参数。

返回值：当创建线程成功时，函数返回0；若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。EAGAIN表示系统中的线程数量达到了上限，EINVAL表示线程的属性非法。

pthread_join()和pthread_exit()函数：线程结束

pthread_join()函数用来等待一个线程运行结束，此函数时阻塞函数，一直到被等待的线程结束为止，函数才返回并且收回被等待线程的资源，函数原型为：

int pthread_join(pthread_t th,void **thread_return);

参数列表：

th：线程的标识符，即pthread_create()函数创建线程成功后的值，即0。

thread_return：线程的返回值，它是一个指针，可以用来存储被等待线程的返回值，如上例中ret_join，当线程返回时可以返回一个指针，pthread_join()在等待的线程返回时获得此值。这个参数是一个指向指针的指针类型参数，再调用此函数来获得线程参数的时候需要注意通常使用一个指针变量的地址来表示。上述例子中先建立了一个int类型的指针，int *ret_join = NULL，然后调用函数pthread_join()函数来获得线程退出时的传出值。线程函数（start_routine()）的 结束方式有两种，一种是线程函数运行结束，不用返回结果；另一种是通过函数pthread_exit()来实现，将结果传出，函数原型为：

void pthread_join((void *retval)_attribute_(noreturn));

参数retval时函数的返回值，这个值可以被pthread_join()函数捕获，通过thread_return参数来获得。

线程的属性

前面我们说到，pthread_create()函数中，参数列表中第二个参数为线程的属性。通常来说，建立线程的时候，使用默认属性就够了，即第二个参数值为NULL，但是很多时候需要调整线程的属性，特别是线程的优先级。

线程的属性结构为pthread_attr_t，在<pthreadtypes.h>中定义。需要注意的是线程的属性值不能直接设置，必须使用相关的函数进行设置。线程属性的初始化函数为pthread_attr_init()，这个函数必须在pthread_create()函数之前调用。属性对象主要包括线程的状态、调度优先级、运行栈地址、运行栈大小等。

typedef struct _pthread_attr_s
{
    int _detachstate;                    //线程的终止状态
    int _schedpolicy;                    //调度优先级
    struct _sched_param _schedparam;     //参数
    int _inheritsched;                   //继承
    int _scope;                          //范围
    size_t _guardsize;                   //保证尺寸
    int _stackaddr_set;                  //运行栈
    void *stackaddr;                     //线程运行栈地址
    size_t _stacksize;                   //线程运行栈大小
}pthread_attr_t;

线程的优先级也是经常需要设置的属性，有两个函数进行控制：pthread_attr_getschedparam()函数用来获得线程的优先级，pthread_attr_setschedparam()函数用来设置线程的优先级。即设置线程优先级的操作方法是先将优先级取出来，然后对需要设置的参数加以修改后再放回去。

//需要包含头文件
#include <sched.h>
pthread_attr_t attr;
pthread_t pt;
struct sched_param sch;
pthread_attr_init(&attr);        //初始化属性设置
pthread_attr_getschedparam(&attr,&sch);    //获得当前线程的属性
sch.sched_priority = 256;        //设置线程的优先级为256
pthread_attr_setschedparam(&attr,&sch);    //设置线程优先级
pthread_create(&pt,&attr,(void*)start_routine,&run);        //创建线程

线程间通信

一般来说，线程间通信的方式有如下几种：

临界区：通过多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问

互斥量：采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问

互斥量（互斥锁）是用来保护一段临界区的，它可以保证某段时间内只有一个线程在执行一段代码或者访问某个资源。与线程互斥有关的函数如下：

pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_mutex_t errchkmutea = PTHREAD__ERRORCHECK_MUTEX_INITIALIZER_NP;
int pthread_mutex_t init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr);//互斥初始化
int pthread_mutex_lock(pthread_mutex_t *mutex);        //锁定互斥
int pthread_mutex_trylock(pthread_mutex_t *mutex);     //互斥预锁定
int pthread_mutex_unlock(pthread_mutex_t *mutex);      //互斥解锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);     //销毁互斥

pthread_mutex_init()函数初始化一个mutex变量，结构pthread_mutex_t为系统内部私有的数据类型，在使用时直接用pthread_mutex_t就可以。pthread_mutex_lock()声明开始用互斥锁上锁，此后的代码直至调用pthread_mutex_unlock()位置，均不能执行被保护区域的代码，也就是说，在同一时间内只能有一个线程执行，当一个线程执行到pthread_mutex_lock()处时，如果该锁此时被另一个线程使用，那么此线程将被阻塞，即程序将等待另一个线程释放此互斥锁。互斥锁使用完毕后一定要记得释放资源，调用pthread_mutex_destroy()函数进行资源的释放。

互斥量通常用来解决生产者消费者问题。

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
void *producter(void *arg);     //生产者函数
void *consumer(void *arg);      //消费者函数
int buffer = 0;                 //缓冲区计数值
pthread_mutex_t mutex;          //互斥锁
int running = 1;                //线程运行控制
int main()
{
    pthread_t con;      //消费者线程参数
    pthread_t pro;      //生产者线程参数
    pthread_mutex_init(&mutex,NULL);     //初始化互斥锁
    pthread_create(&pro,NULL,(void*)producter,NULL);      //创建生产者线程
    pthread_create(&con,NULL,(void*)consumer,NULL);      //创建消费者线程
    sleep(1);       //等待线程创建
    running = 0;    //设置线程退出值
    pthread_join(con,NULL);     //等待消费者线程退出
    pthread_join(pro,NULL);     //等待生产者线程退出
    pthread_mutex_destroy(&mutex);      //销毁互斥锁
    return 0;
}
//生产者线程函数
void *producter(void *arg)
{
    while(running)
    {
        pthread_mutex_lock(&mutex);     //进入互斥区域
        buffer++;
        printf("生产者，数量：%d\n",buffer);
        pthread_mutex_unlock(&mutex);
    }
}
//消费者线程函数
void *consumer(void *arg)
{
    while(running)
    {
        pthread_mutex_lock(&mutex);
        buffer--;
        printf("消费者，数量：%d\n",buffer);
        pthread_mutex_unlock(&mutex);
    }
}

上述程序中用线程互斥的方法构建了一个生产者和消费者的例子，创建了两个线程，prodecter()用于生产，consumer()用于消费。声明了一个互斥变量mutex，在俩线程中使用线程互斥锁pthread_mutex_lock()函数和pthread_mutex_unlock()来保护对公共变量buffer的访问。

信号量：为控制具有有限数量的用户资源而设计的，它允许多个线程在同一时刻去访问同一个资源，但一般需要限制同一时刻访问此资源的最大线程数目

信号量其实是一个非负的整数计数器，用来实现对公共资源的控制。在公共资源增加的时候，信号量的值增加；当公共资源消耗的时候，信号量的值减少；只有当信号量的值大于0的时候，才能访问信号量所代表的公共资源。

sem_init()：线程信号量初始化函数

int sem_init(sem_t *sem,int _pshared,unsigned int _value);

参数sem指向信号量结构的一个指针，当信号量初始化成功的时候，可以使用这个指针进行信号量的增加减少操作；参数pshared用于表示信号量的共享类型，不为0时这个信号量可以在进程间共享，否则这个信号量只能在当前进程的多个线程之间共享；参数value用于设置信号量初始化时的信号量的值。

sem_post()：线程信号量增加函数，用来增加信号量的值，每次增加的值为1。当有线程等待这个信号量的时候，等待的线程将返回。

sem_wait()：线程信号量等待函数，用来减少信号量的值，如果信号量的值为0，则线程会一直阻塞到信号量的值大于0为止，sem_wait()函数每次使信号量的值减少1，当信号量的值为0时不再减少。

sem_destroy()：线程信号量销毁函数，用来释放信号量sem。

信号量也可用于解决生产者消费者问题。如果使用信号量来解决上述提到过的生产者消费者问题的话，代码如下：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
void *producter(void *arg);     //生产者函数
void *consumer(void *arg);      //消费者函数
sem_t sem;
int running = 1;                //线程运行控制
int main()
{
    pthread_t con;      //消费者线程参数
    pthread_t pro;      //生产者线程参数
    sem_init(&sem,0,16);        //信号量初始化
    pthread_create(&pro,NULL,(void*)producter,NULL);      //创建生产者线程
    pthread_create(&con,NULL,(void*)consumer,NULL);      //创建消费者线程
    sleep(1);       //等待线程创建
    running = 0;    //设置线程退出值
    pthread_join(con,NULL);     //等待消费者线程退出
    pthread_join(pro,NULL);     //等待生产者线程退出
    sem_destroy(&sem);          //销毁互斥锁
    return 0;
}
//生产者线程函数
void *producter(void *arg)
{
    int sem_value = 0;      //信号量的初始值为0
    while(running)
    {
        sleep(1);
        sem_post(&sem);                     //信号量增加
        sem_getvalue(&sem,&sem_value);      //获得信号量的值
        printf("生产者，数量：%d\n",sem_value);
    }
}
//消费者线程函数
void *consumer(void *arg)
{
    int sem_value = 0;
    while(running)
    {
        sleep(1);
        sem_wait(&sem);                 //等待信号量
        sem_getvalue(&sem,&sem_value);
        printf("消费者，数量：%d\n",sem_value);
    }
}

事件（信号）：通过通知操作的方式来保持多线程同步，还可以方便地实现多线程优先级的比较操作

多线程共享资源

（1）堆。由于堆是在进程空间中开辟出来的，所以它是理所当然地被线程共享的

（2）全局变量。它是与具体某一函数无关，所以也与特定线程无关，因此也是共享的

（3）静态变量。虽然对于局部变量来说，它在代码中是存储在在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的.bss和.data段，是共享的

（4）文件等公用资源。这个是共享的，使用这些公共资源的线程必须同步

多线程独享资源

（1）栈。栈是每个线程独享的

（2）寄存器。这个可能会误解，因为电脑的寄存器是物理的，每个线程去取值难道不一样吗？其实线程里存放的是副本，包括程序计数器PC

线程共享的环境包括：进程代码段、进程的公有数据(利用这些共享的数据，线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。

除此之外，线程还有很多其个性：（1）线程ID。每个线程都有自己的线程ID，这个ID在本进程中是唯一的。进程用此来标识线程。（2）寄存器组的值。由于线程间是并发运行的，每个线程有自己不同的运行线索，当从一个线程切换到另一个线程上 时，必须将原有的线程的寄存器集合的状态保存，以便将来该线程在被重新切换到时能得以恢复。（3）线程的堆栈。堆栈是保证线程独立运行所必须的。线程函数可以调用函数，而被调用函数中又是可以层层嵌套的，所以线程必须拥有自己的函数堆栈， 使得函数调用可以正常执行，不受其他线程的影响。（4）错误返回码。由于同一个进程中有很多个线程在同时运行，可能某个线程进行系统调用后设置了errno值，而在该 线程还没有处理这个错误，另外一个线程就在此时被调度器投入运行，这样错误值就有可能被修改。所以，不同的线程应该拥有自己的错误返回码变量。（5）线程的信号屏蔽码。由于每个线程所感兴趣的信号不同，所以线程的信号屏蔽码应该由线程自己管理。但所有的线程都 共享同样的信号处理器。（6）线程的优先级。由于线程需要像进程那样能够被调度，那么就必须要有可供调度使用的参数，这个参数就是线程的优先级。

参考文章：https://blog.csdn.net/sinat_21026543/article/details/81912378