线程

线程

pthread 线程

概念：
线程是轻量级进程；
一般是一个进程中的多个任务（一进程可以有多个线程）；
进程是系统中最小的资源分配单位；
线程是系统中最小的执行单位。
特征：
1、共享资源
2、效率高 30%
3、三方库： pthread clone posix
4.、编写代码头文件： pthread.h
5、 编译代码加载库： gcc x.c -lpthread
优点：
比多进程节省资源，可以共享变量。
缺点：
1.线程和进程相比，稳定性，稍微差些
2.线程的调试gdb，相对麻烦些，因为并发

线程与进程区别

资源：
1.线程比进程多了共享资源。
2.线程又具有部分私有资源。
3.进程间只有私有资源没有共享资源。
空间：
1.进程空间独立，不能直接通信。
2.线程可以共享空间，可以直接通信。
不同点：
1.启动代价不一样，进程启动需要3G空间，线程启动只需要8M
2.进程变量不共享
3.稳定性差异：
项目任务复杂，用进程做；
简单小任务，用线程做；
共同点：
都能并发

线程的设计框架 posix

创建多线程 ——>线程空间操作 ——>线程资源回收

创建多线程：

pthread_create

函数原型

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);

功能：
该函数可以创建指定的一个线程。
参数：
thread 线程id，需要实现定义并由该函数返回。
attr 线程属性，一般是NULL，表示默认属性。
start_routine 指向指针函数的函数指针。
本质上是一个函数的名称即可。称为（th） 回调函数,是线程的执行空间。
arg 回调函数的参数，即参数3的指针函数参数。
返回值：
成功 0
失败 错误码

注意：
一次pthread_create执行只能创建一个线程。
每个进程至少有一个线程称为主线程。
主线程退出则所有创建的子线程都退出。
主线程必须有子线程同时运行才算多线程程序。
线程id是线程的唯一标识，是CPU维护的一组数字。
pstree 查看系统中多线程的对应关系。
多个子线程可以执行同一回调函数。

pthread_self

函数原型

pthread_t pthread_self(void);

功能：
获取当前线程的线程id
参数：无
返回值：
成功 返回当前线程的线程id
失败 -1；

线程的退出

1： 自行退出 = =自杀 ==子线程自己退出
函数原型

void pthread_exit(void *retval);  exit  return p;

功能：
子线程自行退出
参数：
retval 线程退出时候的返回状态，临死遗言。
返回值：
无
2： 强制退出 ==他杀 ==主线程结束子线程
函数原型

int pthread_cancel(pthread_t thread);

功能：
请求结束一个线程
参数：
thread 请求结束一个线程tid
返回值：
成功 0
失败 -1；

线程的回收

线程的回收机制 ：
（1）不同与进程没有孤儿线程和僵尸线程。
（2）主线程结束任意生成的子线程都会结束。
（3）子线程的结束不会影响主线程的运行。
函数原型

  int pthread_join(pthread_t thread, void **retval);    

功能：
通过该函数可以将指定的线程资源回收，该函数具有阻塞等待功能，如果指定的线程没有结束，则回收线程会阻塞。
参数：
thread 要回收的子线程tid
retval 要回收的子线程返回值/状态。==》ptread_exit(值);
返回值：
成功 0
失败 -1；

子线程的回收策略：
1、如果预估子线程可以有限范围内结束则正常用pthread_join等待回收。
2、如果预估子线程可能休眠或者阻塞则等待一定时间后强制回收。
3、如果子线程已知必须长时间运行则，不再回收其资源。

分离属性

目的：
线程消亡，自动回收空间。

pthread_attr_init

函数原型

int pthread_attr_init(pthread_attr_t *attr);

功能：
初始化一个attr的变量
参数：
attr，需要变量来接受初始值
返回：
0 成功，
非0 错误；

pthread_attr_destroy

   int pthread_attr_destroy(pthread_attr_t *attr);

功能：销毁attr变量。
参数：attr，属性变量
返回：
0 成功，
非0 错误；

pthread_attr_setdetachstate

 int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

功能：
把一个线程设置成相应的属性
参数：
attr，属性变量，有init函数初始化他。
detachstate：有2个可选值，
PTHREAD_CREATE_DETACHED

pthread_deatch

函数原型

int pthread_deatch(pthread_t thread);

功能：设置分离属性
参数：线程id号，填自己的id

pthread_cleanup_push

void pthread_cleanup_push(void (*routine)(void *)， void *arg);

功能：注册一个线程清理函数
参数：
routine，线程清理函数的入口
arg，清理函数的参数。
返回值：无

pthread_cleanup_pop

void pthread_cleanup_pop(int execute);

功能：调用清理函数
参数：
execute，非0 执行清理函数
0 ，不执行清理

返回值：无

线程的控制（互斥与同步）

线程的互斥

概念：
互斥 ：在多线程中对临界资源的排他性访问。
框架：
定义互斥锁 ——>初始化锁 ——>加锁 ——>解锁 ——>销毁

定义

pthread_mutex_t mutex;

初始化锁

int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr);

功能：
将已经定义好的互斥锁初始化。
参数：
mutex 要初始化的互斥锁
atrr 初始化的值，一般是NULL表示默认锁
返回值：
成功 0
失败 非零

加锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

功能：
用指定的互斥锁开始加锁代码

加锁后的代码到解锁部分的代码属于原子操作， 在加锁期间其他进程/线程都不能操作该部分代码
如果该函数在执行的时候，mutex已经被其他部分 使用则代码阻塞 。

参数： mutex 用来给代码加锁的互斥锁
返回值：
成功 0
失败 非零

解锁

int pthread_mutex_unlock(pthread_mutex_t *mutex);

功能：
将指定的互斥锁解锁。

注意：解锁之后代码不再排他访问，一般加锁解锁同时出现。

参数：用来解锁的互斥锁
返回值：
成功 0
失败 非零

销毁

 int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能：
使用互斥锁完毕后需要销毁互斥锁
参数：mutex 要销毁的互斥锁
返回值：
成功 0
失败 非零

trylock

int pthread_mutex_trylock(pthread_mutex_t *mutex);

功能：类似加锁函数效果，唯一区别就是不阻塞。
参数：mutex 用来加锁的互斥锁
返回值：
成功 0
失败 非零
E_AGAIN

线程的同步

同步：有一定先后顺序的对资源的排他性访问。
同步原因：互斥锁可以控制排他访问但没有次序。
信号量的分类：
1、无名信号量 ——>线程间通信
2、有名信号量 ——>进程间通信
框架：
信号量的定义 ——>信号量的初始化 ——>信号量的PV操作
——>信号量的销毁。

信号量的定义 ：

   sem_t sem;

信号量的类型 + 信号量的变量

信号量的初始化：

int sem_init(sem_t *sem, int pshared, unsigned int value);

功能：将已经定义好的信号量赋值。
参数：
sem 要初始化的信号量
pshared = 0 （表示线程间使用信号量）；
pshared!=0 （表示进程间使用信号量）；
value 信号量的初始值，一般无名信号量都是二值信号量（0 1） ：
0 表示红灯，进程暂停阻塞；
1 表示绿灯，进程可以通过执行；
返回值：
成功 0
失败 -1；

信号量的PV 操作

P ：申请资源——申请一个二值信号量
V ：释放资源——释放一个二值信号量

P操作对应函数 ：sem_wait();
V操作对应函数 ：sem_post();

int sem_wait(sem_t *sem);

功能：
判断当前sem信号量是否有资源可用。
如果sem有资源(==1)，则申请该资源，程序继续运行；
如果sem没有资源(==0)，则线程阻塞等待，一 旦有资源；
则自动申请资源并继续运行程序；

注意：sem 申请资源后会自动执行 sem = sem - 1;

参数：
sem 要判断的信号量资源
返回值：成功 0
失败 -1

int sem_post(sem_t *sem);

功能：
函数可以将指定的sem信号量资源释放；
并默认执行，sem = sem+1;
线程在该函数上不会阻塞。
参数：sem 要释放资源的信号量
返回值：
成功 0
失败 -1；

信号量的销毁

int sem_destroy(sem_t *sem);
功能：使用完毕将指定的信号量销毁
参数：sem要销毁的信号量
返回值：成功 0
失败 -1；

示例代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
sem_t sem_mem;//=3;
int MEM[3]={0};
pthread_mutex_t mutex;

int get_mem()
{
    sem_wait(&sem_mem);
    int i = 0 ;
    pthread_mutex_lock(&mutex);
    for(i = 0 ;i<3;i++)
    {
    
        if(0 == MEM[i])
        {
            MEM[i] = 1;
            break;
        }
    }
    pthread_mutex_unlock(&mutex);

    return i;
}

int set_mem(int id)
{
    pthread_mutex_lock(&mutex);
    MEM[id] = 0;
    pthread_mutex_unlock(&mutex);
    sem_post(&sem_mem);
}
void* th(void* arg)
{
    int id = get_mem();
    printf("get mem id %d , tid %lu\n",id,pthread_self());
    sleep(rand()%5);
    printf("relese mem id:%d ,tid %lu\n",id,pthread_self());
    set_mem(id);


    return NULL;
}
int main(int argc, char *argv[])
{
    int i = 0 ;
    sem_init(&sem_mem,0,3);
    pthread_mutex_init(&mutex,NULL);
    pthread_t tid[10]={0};
    for(i=0;i<10;i++)
    {
        pthread_create(&tid[i],NULL,th,NULL);
    }
    for(i=0;i<10;i++)
    {
        pthread_join(tid[i],NULL);
    }
    pthread_mutex_destroy(&mutex);
    sem_destroy(&sem_mem);
    return 0;
}

总结

注意事项

1.互斥锁是一个结构体
2.有公共资源、全局变量时，尽量要考虑锁不锁

重点：

产生死锁的原因主要是：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。
其次，进程运行推进顺序与速度不同，也可能产生死锁。
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。