IO进程(线程Thread)

线程Thread

1.什么是线程

1.1 概念

线程是一个轻量级的进程，为了提高系统的性能引入线程。

线程和进程都参与统一的调度。

在同一个进程中可以创建的多个线程, 共享进程资源。

（Linux里同样用task_struct来描述一个线程）

1.2 进程和线程的区别

相同点：都为操作系统提供了并发执行能力

不同点：

调度和资源：线程是系统调度的最小单位，进程是资源分配的最小单位

地址空间方面：同一个进程创建的多个线程共享该进程的资源；进程的地址空间相互独立

通信方面：线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；进程通信比较复杂，需要借助进程间的通信机制(借助3g-4g内核空间)

安全性方面：线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全

面试题：程序什么时候该使用线程？什么时候用进程？

对资源的管理和保护要求高，不限制开销和效率时，使用多进程。

要求效率高、速度快的高并发环境时，需要频繁创建、销毁或切换时，资源的保护管理要求不是很高时，使用多线程。

1.3 线程资源

共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID

私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈(局部变量, 返回地址)、错误号 (errno)、信号掩码和优先级、执行状态和属性

2.函数接口

2.1 创建线程：pthread_create

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,

void *(*start_routine) (void *), void *arg);

功能：创建线程

头文件;

                #include <ptthread.h>

参数： thread：线程标识

            attr：线程属性， NULL：代表设置默认属性

            start_routine：函数名：代表线程函数（自己写的）

            arg：用来给前面函数传参

返回值：成功：0

              失败：错误码

编译的时候需要加 -pthread 链接动态库

创建线程：

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

//线程函数
void *handler_thread(void *arg)
{
    printf("in handler_thread\n");
    while (1)
        ; //让从线程不退出，进程状态l也就是多线程
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
    {
        perror("create thread err");
        return -1;
    }
    printf("in main\n");
    while (1)
        ; //不能让整个进程结束
    return 0;
}

2.2 退出线程：pthread_exit

void pthread_exit(void *value_ptr)

头文件同上

功能：用于退出线程的执行

参数：value_ptr：线程退出时返回的值

 

2.3 回收线程资源

int pthread_join(pthread_t thread, void **value_ptr)

功能：用于等待一个指定的线程结束，阻塞函数

参数：thread：创建的线程对象,线程ID

     value_ptr：指针*value_ptr指向线程返回的参数， 一般为NULL

返回值：成功 ： 0

       失败：errno

int pthread_detach(pthread_t thread);

功能：让线程结束时自动回收线程资源,让线程和主线程分离,非阻塞函数

参数：thread：线程ID

非阻塞式的，例如主线程分离(detach)了线程T2，那么主线程不会阻塞在pthread_detach()，pthread_detach()会直接返回，线程T2终止后会被操作系统自动回收资源

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

//线程函数
void *handler(void *arg)
{
    printf("in handler\n");
    //pthread_exit(NULL); //让从线程退出
    while (1) //让从线程不退出
        ;
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler, NULL) != 0)
    {
        perror("create thread err");
        return -1;
    }
    printf("in main\n");

    //回收指定线程资源
    pthread_join(tid,NULL);
    //pthread_detach(tid);

    while(1)
        ;//不让整个进程结束
    return 0;
}

练习：输入输出，quit结束

通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。

（1）全局变量进行通信

（2）加上标志位(flag)，实现主线程输入一次，线程函数打印一次， int flag = 0;

//主线程输入，从线程输出，quit结束
//使用flag全局变量
#include <stdio.h>
#include <pthread.h>
#include <string.h>

char buf[33];
int flag = 0; //为了进行线程间通讯，保证让主线程输入一次然后从线程输出一次
//线程函数
void *handler(void *arg)
{
    printf("in handler\n");
    //pthread_exit(NULL); //让从线程退出
    while (1)//让从线程不退出
    {
        if (flag)
        {
            if(strcmp(buf,"quit") == 0)
                break;
            printf("%s\n", buf);
            flag--;
        }

    }
    
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler, NULL) != 0)
    {
        perror("create thread err");
        return -1;
    }
    printf("in main\n");
    while(1)//不让整个进程结束
    {
        if(!flag)
        {
            scanf("%s", buf);
            flag++;
            if (strcmp(buf, "quit") == 0)
                break;
        }
    }
    return 0;
}

3.同步

3.1 概念

同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情

(异步：异步则反之，并非一定需要一件事做完再做另一件事。）

3.2 同步机制

通过信号量实现线程间同步。

信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待.

信号量代表某一类资源，其值表示系统中该资源的数量:

信号量的值>0,表示有资源可以用, 可以申请到资源, 

信号量的值<=0, 表示没有资源可以通用, 无法申请到资源, 阻塞.

信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)

sem_init: 信号量初始化

sem_wait: 申请资源,P操作, 如果没有资源可以用, 阻塞,-1

sem_post: 释放资源,V操作, 非阻塞 +1

3.3 函数接口

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

功能：初始化信号量   

参数：sem：初始化的信号量对象

    pshared：信号量共享的范围(0: 线程间使用   非0:1进程间使用)

    value：信号量初值

返回值：成功 0

       失败 -1

int sem_wait(sem_t *sem)

功能：申请资源  P操作 

参数：sem：信号量对象

返回值：成功 0

       失败 -1

注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞

int sem_post(sem_t *sem)

功能：释放资源  V操作      

参数：sem：信号量对象

返回值：成功 0

      失败 -1

注：释放一次信号量的值加1，函数不阻塞

头文件：

                #include <semaphore.h>

//主线程输入，从线程输出，quit结束
//使用同步sem
#include <semaphore.h>
#include <stdio.h>
#include <pthread.h>
#include <string.h>

char buf[33];
sem_t sem;
sem_t sem2;

void *handler(void *arg)
{
    while(1)
    {
        //申请资源
        sem_wait(&sem);
        if (!strcmp(buf, "quit"))
            break;
        printf("%s\n", buf);
        //释放资源
        sem_post(&sem2);
    }
}

int main(int argc, char const *argv[])
{
    pthread_t tid;

    //创建从线程
    if(pthread_create(&tid, NULL, handler, NULL))
    {
        perror("pthread create err");
        return -1;
    }

    //初始化信号量
    if (sem_init(&sem, 0, 0))
    {
        perror("sem init err");
        return -1;
    }
    if (sem_init(&sem2, 0, 0))
    {
        perror("sem2 init err");
        return -1;
    }

    //主线程
    while(1)
    {
        //申请资源
        sem_post(&sem2);
        scanf("%s", buf);
        //释放资源
        sem_post(&sem);
        if (strcmp(buf, "quit") == 0)
            break;
    }

    pthread_join(tid, NULL);

    return 0;
}

4.互斥

4.1 概念

互斥：多个线程在访问临界资源时，同一时间只能一个线程访问

临界资源：一次仅允许一个线所使用的资源

临界区：指的是一个访问共享资源的程序片段

互斥锁：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。

pthread_mutex_init

pthread_mutex_lock

pthread_mutex_unlock

4.2 函数接口

int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr)

功能：初始化互斥锁  

参数：mutex：互斥锁

    attr:  互斥锁属性  //  NULL表示缺省属性

返回值：成功 0

      失败 -1

int pthread_mutex_lock(pthread_mutex_t *mutex)

功能：申请互斥锁     

参数：mutex：互斥锁

返回值：成功 0

      失败 -1

注：和pthread_mutex_trylock区别：pthread_mutex_lock是阻塞的；pthread_mutex_trylock不阻塞，如果申请不到锁会立刻返回

int pthread_mutex_unlock(pthread_mutex_t *mutex)

功能：释放互斥锁     

参数：mutex：互斥锁

返回值：成功 0

      失败 -1

int pthread_mutex_destroy(pthread_mutex_t *mutex)

功能：销毁互斥锁     

参数：mutex：互斥锁

//互斥
//用互斥实现数组的来回翻转

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

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;

void *handler_p(void *arg) //打印函数
{
    while(1)
    {
        pthread_mutex_lock(&lock);
        for (int i = 0; i < 10; i++)
        {
            printf("%d", a[i]);
        }
        printf("\n");
        pthread_mutex_unlock(&lock);
        sleep(1);
    }

    return NULL;
}

void *handler_s(void *arg) //交换函数
{
    int t = 0;
    while (1)
    {
        pthread_mutex_lock(&lock);
        for (int i = 0; i < 5; ++i)
        {
            t = a[i];
            a[i] = a[9 - i];
            a[9 - i] = t;
        }
        pthread_mutex_unlock(&lock);
    }

    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid1;
    pthread_t tid2;
    if (pthread_create(&tid1, NULL, handler_p, NULL))
    {
        perror("pthread create err");
        return -1;
    }
    if(pthread_create(&tid2, NULL, handler_s, NULL))
    {
        perror("pthread create err");
        return -1;
    }

    //初始化互斥锁
    if (pthread_mutex_init(&lock,NULL))
    {
        perror("init err");
        return -1;
    }


    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    pthread_mutex_destroy(&lock);

    return 0;
}

补充：死锁

是指两个或两个以上的进程或线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

死锁产生的四个必要条件

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

5.条件变量

条件变量用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。

一般和互斥锁搭配使用，实现同步机制:

pthread_cond_init(&cond,NULL); //初始化条件变量

使用前需要上锁：

pthread_mutex_lock(&lock);  //上锁

判断条件

pthread_cond_wait(&cond, &lock);      //阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁

pthread_cond_signal(&cond); //产生条件，不阻塞

pthread_cond_destroy(&cond); //销毁条件变量

注意： 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件

为什么pthread_cond_wait前要加互斥锁：防止调用 pthread_cond_wait之前其他线程改变条件，从而发生错乱。

例如：赚钱和花钱

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

//条件变量
int money;
pthread_mutex_t lock;
pthread_cond_t cond;
pthread_cond_t cond2;

void *spend_m(void *arg) //花钱
{
    while(1)
    {
        pthread_mutex_lock(&lock);
        if (money < 100)
        {
            pthread_cond_wait(&cond, &lock);
        }
        while(money >= 100)
        {
            money -= 100;
            printf("spend 100 dollars\n");
        }
        if (money < 100)
        {
            pthread_cond_signal(&cond2);
        }
        pthread_mutex_unlock(&lock);
    }
    
    return NULL;
}

//赚钱
int main(int argc, char const *argv[])
{
    pthread_t tid;
    //初始化
    if(pthread_create(&tid, NULL, spend_m, NULL) != 0)
    {
        perror("pthread create err");
        return -1;
    }
    if(pthread_mutex_init(&lock,NULL))
    {
        perror("lock init err");
        return -1;
    }
    if(pthread_cond_init(&cond,NULL))
    {
        perror("cond init err");
        return -1;
    }
    if(pthread_cond_init(&cond2,NULL))
    {
        perror("cond init err");
        return -1;
    }

    //主线程
    while(1)
    {
        //sleep(2); //为了保证pthread_cond_wait先执行
        pthread_mutex_lock(&lock);
        if (money >= 100)
        {
            pthread_cond_wait(&cond2, &lock);
        }
        scanf("%d", &money);
        if (money >= 100)
        {
            pthread_cond_signal(&cond);
        }
        pthread_mutex_unlock(&lock);
    }

    //回收
    pthread_join(tid,NULL);
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);

    return 0;

}

面试题：linux线程间同步有几种方式?

以下是一些常用的Linux线程间同步方式:

1. 互斥锁(Mutex): 互斥算是一种特殊的同步。使用互斥锁可以确保同一时间只有一个线程可以访问共享资源。当一个线程进入临界区时，会锁定互斥锁，阻止其他线程进入该区域，直到该线程完成操作并释放锁。
2. 信号量(Semaphore): 信号量用于控制对有限数量的资源的访问。它们是一种计数器，可以对其进行递增或递减操作。当信号量值为零时，线程必须等待，直到另一个线程递增该信号量。
3. 条件变量(Condition Variable) : 条件变量用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。