Linux系统编程--线程相关概述

一、Linux线程开发API概要

1、对于Linux的平台上的线程开发已经有对应的pthread库支持，不需要我们自己去构建，我们主要是了解以及操作这些库。

2、Linux线程开发主要设计的基本概念包括三点：
（1）线程 （2）互斥锁（3）条件。这三点里面又包括其他几小点操作方式，详情请见表：

基本概念	操作方式	对应API
线程	1、线程的创建	pthread_create
	2、线程的退出	pthread_exit
	3、 线程的等待	pthread_join
互斥锁	1、创建	pthread_mutex_init
	2、销毁	pthread_mutex_destroy
	3、加锁	pthread_mutex_lock
	4、解锁	pthread_mutex_unlock
条件	1、创建	pthread_cond_init
	2、销毁	pthread_cond_destory
	3、触发	pthread_cond_signal
	4、广播	pthread_cond_broadcast
	5、等待	pthread_cond_wait/timedwait

二. 线程的创建

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
// 返回：若成功返回0，否则返回错误编号

当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。
新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。

2.1 线程退出

#include <pthread.h>
int pthread_exit(void *rval_ptr);

rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：
　　1）线程只是从启动例程中返回，返回值是线程的退出码。
　　2）线程可以被同一进程中的其他线程取消。
　　3）线程调用pthread_exit：

2.2 线程的等待

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号

调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。如果例程只是从它的启动例程返回i，rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。

如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。

2.3 单线程实战举例：

#include <stdio.h>
#include <pthread.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg)>
void *func1(void *arg)//创建func函数，打印对应的arg返回值
{
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*(int *)arg);
        
}
int main()
{
        int ret;
        int param = 100;
        pthread_t t1;//创建线程t1
        ret = pthread_creat(&t1,NULL,func1,(void *)&param);//按照函数的指示一步一步写对应的函数,函数从func1的地址开始运行，
        if(ret == 0)//如果函数创建成功，那么打印创建成功的这一段话
        {
                printf("main:create t1 success\n");
        
        }
        printf("main:%ld\n",(unsigned long)pthread_self());//打印主函数对应的arg值
        pthread_join(t1,NULL);//调用等待函数，执行完过后不会直接退出，而是处于等待状态。
        return 0;
}

注意在编译的时候记得加 -pthread，不然会跳出警告

2.4多线程实战举例

#include <stdio.h>
#include <pthread.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg)>

void *func1(void *arg)
{

        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));

}

void *func2(void *arg)
{
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

}
int main()
{
        int ret;
        int param = 100;
        pthread_t t1;

        pthread_t t2;

        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t1 success\n");

        }
        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t2 success\n");
         }
        printf("main:%ld\n",(unsigned long)pthread_self());

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);
        return 0;
}

当多个线程同时工作的时候，我们打印出来的顺序其实是无序的，可能func1
先执行，也可能func2先执行，为了保证每一个线程都是执行完了的，所以我们需要将这是因为多个线程采用的是共享内存的方法，没有达到同步，所以我们需要采用一些方法让他们同步。这个方法就是互斥锁。

三、互斥锁

3.1 互斥锁的基本原理
1）在访问共享资源后临界区域前，对互斥锁进行加锁。
2）在访问完成后释放互斥锁导上的锁。
3）对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

简单一点来说，就是你在公司有一台公共打印机，但是这台公共打印机是在一个房间里面，当房间里面没人的时候，房门没有锁住，你顺利的打开门进去，将门锁住，开始打印。此时我也想要打印东西，但是过来的时候你在里面打印，并将门锁住，我打不开，只能等你出来我再将们打开，进去打印，保证门里面只有一个人在打印他的东西，打印多少不关心。
对于不打印东西的人来说，你有没有人在里面打印东西都不关心，我是清洁工，你在里面打印东西，我进来做清洁，我们两个没有任何关系，也不存在干扰，这是被允许的，所以我们所以在编码时候，只有锁与锁之间会存在互斥，锁与其他东西不会互斥。

3.2互斥锁的创建以及销毁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号；要用默认的属性初始化互斥量，只需把attr设置为NULL。

3.2加锁以及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t mutex);
int pthread_mutex_trylock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号

我们对刚才的多线程程序进行优化，采用互斥锁的方式来固定打印的顺序：

#include <stdio.h>
#include <pthread.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg)>
int g_data = 0;
pthread_mutex_t mutex;//宏定义互斥锁 mutex为互斥锁的地址

void *func1(void *arg)
{

        pthread_mutex_lock(&mutex);//加锁
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        pthread_mutex_unlock(&mutex);//解锁
}
void *func2(void *arg)
{

        pthread_mutex_lock(&mutex);//加锁
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

        pthread_mutex_unlock(&mutex);//解锁
}
//将两个线程上锁
int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;

        pthread_mutex_init(&mutex,NULL);//设置互斥量的属性，初始化锁

        pthread_mutex_lock(&mutex);//加锁
        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t1 success\n");

        }

        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t2 success\n");

        }
        printf("main:%ld\n",(unsigned long)pthread_self());

        pthread_mutex_unlock(&mutex);//解锁
       
        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);//程序完毕，销毁锁
        return 0;
}
                              

如果将main 函数中的锁去掉，会执行出下面的结果：
你会发现main函数在t1连续打印中执行了一次，这是因为这个main就想当于一个清洁工，我不干涉你的打印，我只是过来做清洁。

3.3 互斥锁死锁

3.3.1基本原理
举个例子： A、B两个线程会同时使用到两个共享变量 m和n，同时每个变量都有自己相应的锁M和N。 这时A线程首先拿到M锁访问m，接下来他需要拿N锁来访问变量n; 而如果此时B线程拿着N锁等待着m的话，你的锁打不开对对应的锁，就造成了线程“死锁”。

3.3.2必要条件
(1)互斥：某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结 束。
(2)占有且等待：一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。
(3)不可抢占：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。
(4)循环等待：存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。
当以上四个条件均满足，必然会造成死锁，发生死锁的进程无法进行下去，它们所持有的资源也无法释放。这样会导致CPU 的吞吐量下降。所以死锁情况是会浪费系统资源和影响计算机的使用性能的。那么，解决死锁问题就是相当有必要的了。

例如：

#include <stdio.h>
#include <pthread.h>

int g_data = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex1;

void *func1(void *arg)//创建线程func1
{

        pthread_mutex_lock(&mutex);
        pthread_mutex_lock(&mutex1);//对func1进行加锁并额外增加一把锁mutex1。

        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        pthread_mutex_unlock(&mutex);
}

void *func2(void *arg)//创建线程func2
{

        pthread_mutex_lock(&mutex1);
        pthread_mutex_lock(&mutex);//对func2也增加一把锁mutex1，使func1 func2 陷入死锁状态。

        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

        pthread_mutex_unlock(&mutex);
}

//当func1  func2 同时有锁时，就会造成死锁了
int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;
     

        pthread_mutex_init(&mutex,NULL);
        pthread_mutex_init(&mutex1,NULL);

        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t1 success\n");

        }

        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t2 success\n");

        }
        printf("main:%ld\n",(unsigned long)pthread_self());

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);
        return 0;
}

这就是当死锁形成的时候，只对一个线程进行执行，且不会退出，他会一直占用这个线程，让其他线程无法进入。

3.3.2 破坏死锁条件
(一)：破坏“占有且等待”条件
方法一：所有的进程在开始运行之前，必须一次性地申请其在整个运行过程中所需要的全部资源。
优点：简单易实施且安全。
缺点：因为某项资源不满足，进程无法启动，而其他已经满足了的资源也不会得到利用，严重降低了资源的利用率，造成 资源浪费。使进程经常发生饥饿现象。

方法二：该方法是对第一种方法的改进，允许进程只获得运行初期需要的资源，便开始运行，在运行过程中逐步释放掉分配到 的已经使用完毕的资源，然后再去请求新的资源。这样的话，资源的利用率会得到提高，也会减少进程的饥饿问题。

(二)：破坏“不可抢占”条件
当一个已经持有了一些资源的进程在提出新的资源请求没有得到满足时，它必须释放已经保持的所有资源，待以后需要使用 的时候再重新申请。这就意味着进程已占有的资源会被短暂地释放或者说是被抢占了。该种方法实现起来比较复杂，且代价也比 较大。释放已经保持的资源很有可能会导致进程之前的工作实效等，反复的申请和释放资源会导致进程的执行被无限的推迟，这 不仅会延长进程的周转周期，还会影响系统的吞吐量。

(三)：破坏“循环等待”条件
可以通过定义资源类型的线性顺序来预防，可将每个资源编号，当一个进程占有编号为i的资源时，那么它下一次申请资源只 能申请编号大于i的资源。 破坏“不可抢占”条件

四、条件控制
4.1 条件控制的基本原理
条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。
　　条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。
　　条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。
　　
4.2 条件控制的相关API
4.2.1 创建及销毁条件变量

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);//创建
int pthread_cond_destroy(pthread_cond_t cond);//销毁
// 返回：若成功返回0，否则返回错误编号

4.2.2 等待

#include <pthread.h>
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, cond struct timespec *restrict timeout);//指定等待时间
// 返回：若成功返回0，否则返回错误编号

4.2.3 触发

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t cond);//触发
int pthread_cond_broadcast(pthread_cond_t cond);//唤醒
// 返回：若成功返回0，否则返回错误编号

4.3 通过条件控制来控制线程
例如：

#include <stdio.h>
#include <pthread.h>
#include <string.h>

int g_data = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;

void *func1(void *arg)
{

        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        while(1){
                pthread_cond_wait(&cond,&mutex);//条件等待，不会直接运行程序，等待条件的触发 
                printf("t1:%d\n",g_data);//打印条件触发时候的t1的值
                printf("t1 run.......\n");
                g_data = 0;
                sleep(1);
        }
}

void *func2(void *arg)
{


        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));
                while(1){
                        pthread_mutex_lock(&mutex);
                        printf("t1 = %d\n",g_data);
                        g_data++;
                        if( g_data == 3){
                                pthread_cond_signal(&cond);//条件满足，使等待的条件开始运行
                        }
                        pthread_mutex_unlock(&mutex);
                        sleep(1);
                }
}
int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;

        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&cond,NULL);//对条件变量进行初始化

        pthread_create(&t1,NULL,func1,(void *)&param);
        pthread_create(&t2,NULL,func2,(void *)&param);

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);

        return 0;
}

每次当t1 等于 3的时候，func1中的条件等待就被触发，此时的func1就开始执行，执行完过后，又令g_data等于 0 ，此时func2又开始执行，当g_data 等于3的时候，func1满足条件又开始循环，这就是通过func2的条件对func1进行控制，就是简单的条件控制。

线程的学习就到此了，在这里祝福大家新年快乐。