苏嵌实训——day15

一 线程

线程的概念：线程是进程的进一步抽象。进程包括两个集合。一个资源集合，一个线程的集合，进程是资源分配的最小单位，线程是系统调度的最小单位。每个进程中必然包含一个线程，那么这个线程被称作主线程。线程的本质是一个在运行的线程函数。线程也属于并发，也会拥有自己的资源：如：Pc程序计数器，时间片，堆，栈，线程号等。线程本身并不会去申请资源，而是共享进程的资源。线程也被称为轻量级的进程，线程间共享全局变量，使得通信时会很方便。

线程不属于标准C库函数，也不属于系统调用，而是属于第三方库，libpthread.so

安装库：sudo apt-get install manpages-posix manpages-posix-dev

1.1 线程基本使用

线程的接口函数：

1.pthread_create

头文件:#include <pthread.h>

原型：int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);
功能：创建一个线程
参数：
    thread：线程号
    attr：线程的属性和设置堆栈的大小
        分离属性：线程结束后，自己回归空间
        非分离属性：线程结束后，由创建者手动去归还空间
        一般填写NULL，一般在后面函数中设置
    start_routine：函数指针，指向了一个返回值是void*，参数是void*的函数
    arg:给线程函数传参使用，一般用于线程间通信使用，如果不传参，填写NULL
返回值：
    如果成功返回 0
    如果错误返回错误码 strerror();

注意：
1.在线程运行过程中，进程结束时资源释放后，线程没有办法执行了。
2.在多线程中，线程中尽量不调用影响整个进程的函数接口，线程本身安全星星不高，一个线程崩溃会造成进程的崩溃。
3.线程中通信的方式2种：1 全局变量 2.参数arg
注意点:如果一个线程对其进行改变，所有线程访问的值都是改变后的值。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//int a = 100;
void *MyFun(void * arg)
{
    
    
    int *p = (int *)arg;
    
    //int a = *(int *)arg;  //线程传参
    printf("我是第一个线程\n");
    printf("子线程获取A的值为%d\n",*p);
    //a = 200;
    *p = 200;
}
int main(int argc, char const *argv[])
{
    
    
    int a = 100;
    pthread_t tid = 0;
    if(pthread_create(&tid,NULL,MyFun,&a) != 0)
    {
    
    
        printf("线程创建失败！\n");
        return -1;
    }
    printf("线程号为%ld\n",tid);
    printf("主线程获取A的值为%d\n",a);
    sleep(1);
    printf("主线程获取A的值为%d\n",a);
    return 0;
}

2.pthread_exit

头文件：#include <pthread.h>
原型：void pthread_exit(void *retval);
功能：结束一个线程
参数：retval:线程结束时的状态，如果不传递填写NULL
返回值：无

3.pthread_join

头文件：#include <pthread.h>
原型：int pthread_join(pthread_t thread, void **retval);
功能：阻塞等待回收指定线程
参数：thread：目标线程号
      retval:线程结束时，exit返回的状态
返回值：成功返回0
        失败返回错误码

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//int a = 100;
void *MyFun(void * arg)
{
    
    
    int *p = (int *)arg;
    
    //int a = *(int *)arg;  //线程传参
    printf("我是第一个线程\n");
    
    sleep(3);
    printf("子线程获取A的值为%d\n",*p);
    //a = 200;
    *p = 200;
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    
    
    int a = 100;
    pthread_t tid = 0;
    if(pthread_create(&tid,NULL,MyFun,&a) != 0)
    {
    
    
        printf("线程创建失败！\n");
        return -1;
    }
    printf("线程号为%ld\n",tid);
    printf("主线程获取A的值为%d\n",a);
    if(0 != pthread_join(tid,NULL))
    {
    
    
        printf("回收资源失败！\n");
        return -1;
    }
    //printf("主线程获取A的值为%d\n",a);
    printf("回收资源成功！\n");
    return 0;
}

4.pthread_detach

头文件：#include <pthread.h>
原型：int pthread_detach(pthread_t thread);
功能：设置线程分离属性
参数：thread：目标线程号
返回值：成功返回0
        失败返回错误码
注意：设置完分离属性后，线程自动归回资源，无需join回收，join会失败

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//int a = 100;
void *MyFun(void * arg)
{
    
    
    int *p = (int *)arg;
    
    //int a = *(int *)arg;  //线程传参
    printf("我是第一个线程\n");
    
    sleep(3);
    printf("子线程获取A的值为%d\n",*p);
    //a = 200;
    *p = 200;
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    
    
    int a = 100;
    pthread_t tid = 0;
    if(pthread_create(&tid,NULL,MyFun,&a) != 0)
    {
    
    
        printf("线程创建失败！\n");
        return -1;
    }
    if(0 != pthread_detach(tid))
    {
    
    
        printf("设置分离属性失败\n");
        return -1;
    }
    printf("线程号为%ld\n",tid);
    printf("主线程获取A的值为%d\n",a);
    if(0 != pthread_join(tid,NULL))
    {
    
    
        printf("回收资源失败！\n");
        return -1;
    }
    //printf("主线程获取A的值为%d\n",a);
    printf("回收资源成功！\n");
    return 0;
}

5. pthread_self

原型：pthread_t pthread_self(void)
功能：获取自己的线程号
参数：无
返回值：成功会返回一个线程ID号
6.pthread_cancel
原型：int pthread_cancel(pthread_t thread);
功能：申请结束一个线程
参数：目标结束的线程号
返回值：成功返回0，失败返回非0

#include <stdio.h>
#include <pthread.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//int a = 100;
void *MyFun(void * arg)
{
    
    
    int *p = (int *)arg;
    int n = 3;
    //int a = *(int *)arg;  //线程传参
    sleep(3);
    printf("我是第一个线程,我的线程ID是%ld\n",pthread_self());  
    
    printf("子线程获取A的值为%d\n",*p);
    //a = 200;
    *p = 200;
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    
    
    int a = 100;
    pthread_t tid = 0;
    if(pthread_create(&tid,NULL,MyFun,&a) != 0)
    {
    
    
        printf("线程创建失败！\n");
        return -1;
    }
    if(0 != pthread_detach(tid))
    {
    
    
        printf("设置分离属性失败\n");
        return -1;
    }
    pthread_cancel(tid);  //发送一个申请取消线程的信号
    printf("线程号为%ld\n",tid);
    printf("主线程获取A的值为%d\n",a);
    //printf("主线程获取A的值为%d\n",a);
    printf("回收资源成功！\n");
    sleep(5);
    return 0;
}

练习3

创建两个线程，一个线程对全局变量count循环相加，每一秒加一次，另一个线程循环打印count的值，每一秒打印一次。

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
int count = 0;
int flag = 0;
void * myfun1(void *arg)
{
    
    
    while(1)
    {
    
    
        if(flag == 0)
        {
    
    
            count++;
            //sleep(1);
            flag = 1;
        }
    }
}
int main(int argc, char const *argv[])
{
    
    
    pthread_t tid = 0;
    if(0 != pthread_create(&tid,NULL,myfun1,NULL))
    {
    
    
        perror("pthread_create");
        return -1;
    }
    while(1)
    {
    
    
        if(flag == 1)
        {
    
    
            printf("count = %d\n",count);
            flag = 0;
        }
    }
    return 0;
}

1.2 线程同步和互斥

1.2.1同步概念

什么是同步：线程间也存在着竞态的关系，对有些任务是不友好的，所以说线程提供了可以实现让多个线程同步（按一定顺序去执行）。

1.3 无名信号量：又名信号灯

本质是一个全局特殊变量，这个值不允许小于0，

1.3.1 无名信号灯的接口

1. sem_init

头文件：#include <semaphore.h>

       
原型：int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：初始化信号灯
参数：sem:信号灯变量的指针
    pshared:如果是0，代表线程间使用
            如果是非0，代表亲缘间进程使用
    value:信号的初值
返回值：
    成功返回0
    失败返回 -1.

2. sem_wait

头文件：#include <semaphore.h>

       
原型：int sem_wait(sem_t *sem);
功能:申请资源 ----又名p操作， 也就是信号灯-1操作
参数：sem:目标信号灯
返回值：
    成功返回0
    失败返回 -1.
3. sem_post
头文件：#include <semaphore.h>

       
原型：int sem_post(sem_t *sem);
功能:释放资源----又名V操作  也就是信号灯 +1操作
    V操作可以多次执行，但是我i们一般把信号量控制在0和1
参数：sem:目标信号灯
返回值：
    成功返回0
    失败返回 -1.

4. sem_destory

头文件：#include <semaphore.h>

       
原型：int sem_destroy(sem_t *sem);
功能:销毁一个信号灯
参数：sem:目标信号灯
返回值：
    成功返回0
    失败返回 -1.

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <semaphore.h>
int count = 0;
//定义无名信号灯
sem_t sem1;    //给线程1使用，初值应该为0
sem_t sem2;   //给线程2使用，初值应该为1
void * myfun1(void *arg)
{
    
    
    while(1)
    {
    
    
       //申请资源向信号sem1
       sem_wait(&sem1);
       count++;
       sem_post(&sem2);
    }


}
int main(int argc, char const *argv[])
{
    
    
    //初始化无名信号灯，分别初始化值为 1 0
    sem_init(&sem1,0,1);
    sem_init(&sem2,0,0);
    //开始创建线程
    pthread_t tid = 0;
    if(0 != pthread_create(&tid,NULL,myfun1,NULL))
    {
    
    
        perror("pthread_create");
        return -1;
    }
    while(1)
    {
    
    
        sem_wait(&sem2);
        printf("count = %d\n",count);
        sleep(1);
        sem_post(&sem1);
    }
    return 0;
}

练习

共有三个线程，123线程分别打印A B C，循环打印后，最终输出的结果是BCA BCA BCA

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <semaphore.h>
//定义无名信号灯
sem_t sem1;
sem_t sem2;
sem_t sem3;
void* myfun1(void *arg)
{
    
    
    while(1)
    {
    
    
        sem_wait(&sem1);
        printf("B\n");
        sem_post(&sem2);
    }
}
void* myfun2(void *arg)
{
    
    
    while(1)
    {
    
    
        sem_wait(&sem2);
        printf("C\n");
        sem_post(&sem3);
    }
}
int main(int argc, char const *argv[])
{
    
    
    sem_init(&sem1,0,1);
    sem_init(&sem2,0,0);
    sem_init(&sem3,0,0);


    pthread_t tid = 0;
    pthread_t tid1 = 0;
    if(0 != pthread_create(&tid,NULL,myfun1,NULL))
    {
    
    
        perror("pthread_create");
    }
    if(0 != pthread_create(&tid,NULL,myfun2,NULL))
    {
    
    
        perror("pthread_create1");
    }
    while(1)
    {
    
    
        sleep(1);
        sem_wait(&sem3);
        printf("A\n");
        sem_post(&sem1);
    }
    return 0;
}

1.4 线程间的互斥

互斥：与同步机制不同的点在于无需顺序执行，必须保证同一时间内只允许有一个线程去访问临界资源。实质上是保证同一临界区只允许同一时间运行一个临界资源。
临界资源：多线程共享的易改变的资源
临界区：修改临界资源的代码
注意：同步一定会互斥，但是互斥不一定同步
互斥机制：互斥锁

1.pthread_mutex_init

头文件：#include <pthread.h>

原型：int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
功能:动态初始化一把锁
参数：mutex：锁变量的地址
attr：互斥所得属性，NULL缺省默认
返回值：
总是返回 0

2. 静态初始化一把锁

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

3. pthread_mutex_lock

头文件：#include <pthread.h>

原型：int pthread_mutex_lock(pthread_mutex_t *mutex);
功能:尝试枷锁，如果没有抢到锁资源，阻塞等待加锁
参数：mutex：锁变量的地址
返回值：
成功返回 0
失败返回非0

4.pthread_mutex_trylock

头文件：#include <pthread.h>

原型：int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能:尝试加锁，如果没有抢到锁资源，报错返回
参数：mutex：锁变量的地址
返回值：
成功返回 0
失败返回非0

5.pthread_mutex_unlock

头文件：#include <pthread.h>

原型：int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能:解锁操作
参数：mutex：锁变量的地址
返回值：
成功返回 0
失败返回非0

6. pthread_mutex_destroy

头文件：#include <pthread.h>

原型：int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能:销毁一把锁
参数：mutex：锁变量的地址
返回值：
成功返回 0
失败返回非0

练习

目标将全局变量a加到100 0000，使用两个线程去做，每个线程应该各加50 0000次，这种情况还需要同步吗？

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * myfun(void * arg)
{
    
    
    int i = 500000;
    while(i)
    {
    
    
        if(-1 == pthread_mutex_lock(&mutex))
        {
    
    
            perror("lock");
            return NULL;
        }
        //临界区 ---》开始
        int a = count;
        a++;
        count = a; 
        //临界区 ---》结束
        if(-1 == pthread_mutex_unlock(&mutex))
        {
    
    
            perror("lock");
            return NULL;
        }
        i--;
    }
}
int main(int argc, char const *argv[])
{
    
    
    pthread_t tid = 0;
    if(0 != pthread_create(&tid,NULL,myfun,NULL))
    {
    
    
        perror("create");
        return -1;
    }


    int i = 500000;
    while(i)
    {
    
    
        if(-1 == pthread_mutex_lock(&mutex))
        {
    
    
            perror("lock");
            return -1;
        }
        int a = count;
        a++;
        count = a;
        if(-1 == pthread_mutex_unlock(&mutex))
        {
    
    
            perror("lock");
            return -1;
        }
        i--;
    }
    pthread_join(tid,NULL);
    pthread_mutex_destroy(&mutex);
    printf("count = %d\n",count);
    return 0;
}

练习

卖票，共一百张票，有5个人一起卖，设计5个线程，使其票不能重复卖出，并且打印出是哪个线程卖得第多少张票？

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int Ticket = 100;
pthread_mutex_t mutex;
void delay()
{
    
    
    int x = 10000,y;
    while(x--)
    {
    
    
        y = 5000;
        while(y--);
    }
}
void * SaleTicket(void *arg)
{
    
    
    int cur_ticket;
    while (1)
    {
    
    
        pthread_mutex_lock(&mutex);
        cur_ticket = Ticket;
        if(cur_ticket <=0)
        {
    
    
            pthread_mutex_unlock(&mutex);
            break;
        }
        printf("%ld get %d-th ticket!\n",pthread_self(),cur_ticket);
        cur_ticket--;
        Ticket = cur_ticket;
        pthread_mutex_unlock(&mutex);
        delay();
    }
}
int main(int argc, char const *argv[])
{
    
    
    int i,ret;
    pthread_t tid[5] = {
    
    0};
    pthread_mutex_init(&mutex,NULL);  //动态初始化一把锁
    for(i = 0; i < 5;i++)
    {
    
    
        ret = pthread_create(&tid[i],NULL,SaleTicket,NULL);
        if(ret != 0)
        {
    
    
            perror("create");
            return -1;
        }
    }
    for(i = 0; i < 5;i++)
    {
    
    
        void *status;
        pthread_join(tid[i],&status); 
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}

1.5 条件变量

条件变量是为了完成线程间同步指定出来得一种机制，是利用将一个线程挂起等待。然后由另一方发送一个条件成立得信号将其唤醒继续运行得原理。
缺点：等待一方必须要先获取到锁。

1.5.1 函数的接口

1.静态初始化条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
2.动态初始化条件变量
头文件：#include <pthread.h>

原型：int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
功能:动态初始化条件变量
参数：cond：条件变量的地址
attr：使用缺省模式NULL
返回值：
成功返回 0
失败返回非0

3.pthread_cond_wait
头文件：#include <pthread.h>

原型：int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
功能:主动挂起等待信号的到来
参数：cond：条件变量的地址
mutex：锁变量的地址
注意：wait函数和一把锁一起绑定，当这个函数运行后，
1.先进性解锁操作，让这把锁的使用权
2.然后将线程挂起
3.当信号到来时，准备运行之前，需要先尝试加锁
1，2属于原子操作
返回值：
成功返回 0
失败返回非0
4.pthread_cond_signal
头文件：#include <pthread.h>

原型：int pthread_cond_signal(pthread_cond_t *cond);
功能:发送一个条件成立的信号，一次性的，每次只能唤醒一个线程，谁收到谁执行
参数：cond：条件变量的地址
返回值：
成功返回 0
失败返回非0
5. pthread_cond_broadcast
头文件：#include <pthread.h>

原型：int pthread_cond_broadcast(pthread_cond_t *cond);
功能:发送一个条件成立的信号,唤醒所有等待的线程，一个广播信号
参数：cond：条件变量的地址
返回值：
成功返回 0
失败返回非0
6. pthread_cond_destory
头文件：#include <pthread.h>

原型：int pthread_cond_destory(pthread_cond_t *cond);
功能: 销毁一个条件变量
参数：cond：条件变量的地址
返回值：
成功返回 0
失败返回非0

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int Ticket = 100;
pthread_mutex_t mutex;
pthread_cond_t cond;
void delay()
{
    
    
    int x = 10000,y;
    while(x--)
    {
    
    
        y = 5000;
        while(y--);
    }
}
void * SaleTicketA(void *arg)
{
    
    
    int cur_ticket;
    while (1)
    {
    
    
        pthread_mutex_lock(&mutex);
        cur_ticket = Ticket;
        if(cur_ticket <=0)
        {
    
    
            pthread_mutex_unlock(&mutex);
            break;
        }
        if(cur_ticket == 50)
        {
    
    
            pthread_cond_signal(&cond);  //唤醒另一个线程
        }
        printf("A get %d-th ticket!\n",cur_ticket);
        cur_ticket--;
        Ticket = cur_ticket;
        pthread_mutex_unlock(&mutex);
        delay();
    }
}
void * SaleTicketB(void *arg)
{
    
    
    int cur_ticket;
    while (1)
    {
    
    
        pthread_mutex_lock(&mutex);
        cur_ticket = Ticket;
        if(cur_ticket <=0)
        {
    
    
            pthread_mutex_unlock(&mutex);
            break;
        }
        if(cur_ticket >= 50)
        {
    
    
            pthread_cond_wait(&cond,&mutex);  //释放互斥锁，进入睡眠状态
            cur_ticket = Ticket;
        }
        printf("B get %d-th ticket!\n",cur_ticket);
        cur_ticket--;
        Ticket = cur_ticket;
        pthread_mutex_unlock(&mutex);
        delay();
    }
}
int main(int argc, char const *argv[])
{
    
    
    int i,ret;
    pthread_t tid[2] = {
    
    0};
    pthread_mutex_init(&mutex,NULL);  //动态初始化一把锁
    pthread_cond_init(&cond,NULL);  //初始化条件变量
  
    ret = pthread_create(&tid[0],NULL,SaleTicketA,NULL);
    if(ret != 0)
    {
    
    
        perror("create");
        return -1;
    }
    ret = pthread_create(&tid[1],NULL,SaleTicketB,NULL);
    if(ret != 0)
    {
    
    
        perror("create");
        return -1;
    }  
    for(i = 0; i < 2;i++)
    {
    
    
        void *status;
        pthread_join(tid[i],&status); 
    }
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}