线程

为什么使用线程?

使用fork创建进程以执行新的任务，该方式的代价很高——子进程将父进程的所有资源都复制一遍。

多个进程之间不会直接共享内存。

进程是系统分配资源的基本单位，线程是进程的基本执行单元，一个进程的所有任务都在线程中执行，进程想要执行任务，必须得有线程，进程至少要有一条线程，程序启动会默认开启一条线程，这条线程被称为主线程或UI线程。

什么是线程？

线程是进程内部的一个控制序列。

类比:

创建一个进程，就类似于克隆一个家庭，新的"家庭"与原来的家庭完全相同，但是新"家庭"和原来的家庭完全独立。

进程包含一个或多个线程，就像一个家庭中包含一个或多个家庭成员。

家庭内的各个成员同时做各自的事情，而对于家庭外部的人来说，就是这个家庭同时在做多件事情。

家庭内的每个成员，就是一个线程。每个家庭成员都有自己的个人资源，即线程有自己的局部变量。

所有的家庭成员都能共享这个家庭的资源，即同一个进程内的各个线程，都能共享当前这个进程中的全局变量，除了线程自己的局部变量外，其它资源都共享。

注意:

在单核处理器上，同一个时刻，只能运行一个线程。但是对于用户而言，感觉像是执行了多个线程一样，是因为各个线程在单核CPU上不断进行切换。

线程的优缺点

优点:创建线程比创建进程开销要小。

缺点:

多线程编程要多加小心，很容易发生错误。

多线程调试很困难。

补充:

把一个任务划分为两部分，如果在单核处理器上运行，速度不一定更快。除非能确定这个任务运行在多核处理器上，即两部分可以同时执行。

线程的应用场合

需要让用户感觉同时在做多件事情时。

比如:处理文档的进程，一个线程处理用户编辑，一个线程同时统计用户字数。

当一个应用程序，需要同时处理输入、计算、输出时。

可开3个线程，分别处理输入、计算、输出。

综上所述，即高并发编程。

线程的使用

线程的创建

pthread_create

功能:创建一个新线程。

同时指定该线程的属性、执行函数、执行函数的参数。

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

thread:指向新的线程标识符。

attr:用来设置新线程的属性。

一般取默认属性，即该参数取NULL。

start_routine:该线程的处理函数。

该函数的返回类型和参数类型都是void*。

arg:线程处理函数start_routine的参数。

返回值:

成功:返回0。

失败:返回错误代码。(错误代码，这里略过，其它函数也是如此。)

注意:

使用fork创建进程后，进程马上就启动，执行的是fork后面的代码。

使用pthread_create创建线程后，新线程马上就启动，执行对应的线程处理函数。

线程的终止

pthread_exit

功能:在线程函数内部调用该函数，对本线程进行终止，返回值通过参数retval指定。

函数原型:void pthread_exit (void *retval)

参数：

retval：它指向的数据为线程退出时的返回值，如果不需要接收该线程的返回值，设置NULL即可。

参考补充:

pthread_join(3) — Linux manual page

等待指定线程结束

pthread_join

功能:等待指定线程结束，并获取该线程的返回值。

函数原型:int pthread_join (pthread_t th,void ** thread_return);

参数:

th:线程标识符，指定要的等待的线程。

thread_return:指向(接收)当前线程的返回值。参数类型为void**。

返回值

成功:返回0。

失败:返回错误号。

使用线程程序的编译

定义宏:_REENTRANT——可重入

即:gcc -D_REENTRANT

功能:告诉编译器，编译时需要可重用功能。

即，在编译时，编译部分函数的可重入版本。将共享的资源给本线程独享。

注意:

在单线程程序中，整个程序都是顺序执行的，一个函数在同一时刻只能被一个函数调用，但是在多线程中，由于并发性，一个函数可能同时被多个函数调用，此时这个函数就成了临界资源，很容易造成调用函数时，处理结果的相互影响。

如果一个函数在多线程并发的环境中，每次被调用产生的结果是不确定的，我们就说这个函数是不可重入的/线程不安全的。

编译时，指定线程库。

即:gcc xxx -lpthread

功能:使用系统默认的NPTL线程库。

即，在默认路径中寻找库文件libpthread.so。默认路径为/usr/lib和usr/local/lib

一般使用如下形式即可:

gcc mythread.c -o mythread -D_REENTRANT -lpthread

示例:

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

int my_global;
void* my_thread_handle(void* arg){
    int val;
    val =  *((int*)arg);
    printf("new thread begin,arg=%d\n",val);
    my_global += val;
    sleep(3);
    pthread_exit(&my_global);
    //下面一行不再执行
    printf("new thread end\n");
}

int main(void){
    pthread_t mythread;
    int arg;
    int ret;
    void *thread_return;

    arg = 100;
    my_global = 1000;
    printf("my_global=%d\n", my_global);
    printf("ready create thread...\n");
    ret = pthread_create(&mythread,0,my_thread_handle,&arg);
    if (ret != 0) {
        printf("create thread failed!\n");
        exit(1);
    }
    printf("wait thread finished...\n");
    ret = pthread_join(mythread,&thread_return);
    if (ret != 0) {
        printf("pthread_join failed!\n");
        exit(1);
    }
    printf("wait thread end, return value is %d\n", *((int*)thread_return));
    printf("my_global=%d\n", my_global);
    printf("create thread finished!\n");
    return 0;
}

线程的同步与互斥

线程的互斥:

指某一资源同一时间只允许一个访问者对其进行访问，具有唯一性和排它性。

但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

线程的同步:

指在互斥的基础上(大多数情况)，通过其它机制实现访问者对资源的有序访问。

问题 :同一个进程内的各个线程，共享该进程的全局变量，如果多个线程同时对某个全局变量进行访问时，就可能导致竞态。

有关竞态:多线程对共享资源的访问。

Linux内核分析（七）----并发与竞态

在并发编程中我们常说的“竞态”是什么？

解决办法:对临界区使用信号量、或互斥量。

信号量和互斥量的选择:对于同步和互斥，使用信号量和互斥量都可以实现。使用时选择更符合情况的:

如果要求最多只允许一个线程进入临界区，则使用互斥量。

如果要求多个线程之间的执行顺序满足某个约束，则使用信号量。

信号量

什么是信号量？

此时所指的"信号量"是指用于同一个进程内多个线程之间的信号量。即POSIX信号量，而不是System V信号量。(用于进程之间的信号量)。

用于线程的信号量原理与用于进程之间的信号量原理相同。都有P、V操作。

信号量的表示:sem_t类型。

信号量的初始化

sem_init

功能:对信号量进行初始化。

函数原型:int sem_init (sem_t *sem， int pshared, unsigned int value);

参数:

sem:指向要被初始化的信号量。

pshared：

0表示该信号量是该进程内使用的"局部信号量",不再被其它进程共享。

非0表示该信号量可被其它进程共享，Linux不支持这种信号量。

value:信号量的初值。>=0

返回值:

成功:返回0。

失败:返回错误码。

信号量的P操作

sem_wait

功能:信号量的P操作。-1

函数原型:int sem_wait (sem_t *sem);

参数:

sem:要操作的信号量。

返回值:

成功:返回0。

失败:返回错误码。

信号量的V操作

sem_post

功能:信号量的V操作。+1

函数原型:int sem_post (sem_t *sem);

参数:

sem:要操作的信号量。

返回值:

成功:返回0。

失败:返回错误码。

信号量的删除

sem_destroy

功能:删除信号量。

函数原型:int sem_destroy (sem_t *sem);

参数:

sem:要操作的信号量。

返回值:

成功: 返回0。

失败:返回错误码。

示例:

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

#define BUFF_SIZE 80

char buff[BUFF_SIZE];
sem_t sem;

static void* str_thread_handle(void *arg) 
{
    while(1) {
        //P(sem) -1
        if (sem_wait(&sem) != 0) {
            printf("sem_wait failed!\n");
            exit(1);
        }

        printf("string is: %slen=%d\n", buff, strlen(buff));
        if (strncmp(buff, "end", 3) == 0) {
            break;
        }
    }
}

int main(void)
{
    int ret;
    pthread_t  str_thread;
    void *thread_return;

    ret = sem_init(&sem, 0, 0);
    if (ret != 0) {
        printf("sem_init failed!\n");
        exit(1);
    }

    ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
    if (ret != 0) {
        printf("pthread_create failed!\n");
        exit(1);
    }

    while (1) {
        fgets(buff, sizeof(buff), stdin);

        //V(sem) +1 
        if (sem_post(&sem) != 0) {
            printf("sem_post failed!\n");
            exit(1);
        }

        if (strncmp(buff, "end", 3) == 0) {
            break;
        }
    }

    ret = pthread_join(str_thread, &thread_return);
    if (ret != 0) {
        printf("pthread_join failed!\n");
        exit(1);
    }

    ret = sem_destroy(&sem);
    if (ret != 0) {
        printf("sem_destroy failed!\n");
        exit(1);
    }

    return 0;
}

互斥量

什么是互斥量?

效果等同于初始值为1的信号量。

互斥量的初始化

pthread_mutex_init

功能:初始化互斥量。

函数原型:int pthread_mutex_init(pthread_mutex_t mutex,pthread_mutexattr_t attr);

参数:

mutex:指向被初始化的互斥量。

attr:互斥量的属性，一般取默认属性。

返回值:

成功:返回0。

失败:返回错误码。

互斥量的获取

pthread_mutex_lock

功能:获取互斥量。

函数原型:int pthread_mutex_lock (pthread_mutex_t *mutex);

参数:

mutex:指向要操作的互斥量。

返回值:

成功:返回0。

失败:返回错误码。

互斥量的删除

pthread_mutex_destroy

功能:删除互斥量。

函数原型:int pthread_mutex_destroy (pthread_mutex_t *mutex);

参数:

mutex:指向要操作的互斥量。

返回值:

成功:返回0。

失败:返回错误码。

示例:

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

#define BUFF_SIZE 80

int global_value = 1000;
pthread_mutex_t  lock;

static void* str_thread_handle(void *arg) 
{
    int i = 0;

    for (i=0; i<10; i++) {
        pthread_mutex_lock(&lock);

        if (global_value  > 0) {
            // work
            sleep(1);
            printf("soled ticket(%d) to ChildStation(%d)\n",
                global_value, i+1);
        }
        global_value--;

        pthread_mutex_unlock(&lock);
        sleep(1);
    }
}

int main(void)
{
    int ret;
    pthread_t  str_thread;
    void *thread_return;
    int i;

    ret = pthread_mutex_init(&lock, 0);
    if (ret != 0) {
        printf("pthread_mutex_init failed!\n");
        exit(1);
    }

    ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
    if (ret != 0) {
        printf("pthread_create failed!\n");
        exit(1);
    }

    for (i=0; i<10; i++) {
        pthread_mutex_lock(&lock);

        if (global_value  > 0) {
            // work
            sleep(1);
            printf("soled ticket(%d) to MainStation(%d)\n",
                global_value, i+1);
        }
        global_value--;

        pthread_mutex_unlock(&lock);
        sleep(1);
    }

    ret = pthread_join(str_thread, &thread_return);
    if (ret != 0) {
        printf("pthread_join failed!\n");
        exit(1);
    }

    ret = pthread_mutex_destroy(&lock);
    if (ret != 0) {
        printf("pthread_mutex_destroy failed!\n");
        exit(1);
    }

    return 0;
}

线程的条件变量

什么是条件变量？

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某种情况发生为止，通常条件变量和互斥锁一起使用。

条件变量使我们可以睡眠来等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作:

线程因等待"条件变量的条件成立"而被挂起；

线程使"条件成立"(给出条件成立信号)。

条件的检测是在互斥锁的保护下进行的。如果条件为假，一个线程自动阻塞(挂起)，并释放等待状态改变的互斥锁。

如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。

如果两个进程共享可读写的内存，条件变量可以被用来实现这两个进程间的线程同步。

条件变量初始化

pthread_cond_init

功能:初始化条件变量

函数原型:int pthread_cond_init (pthread_cond_t cond, const pthread_condattr_t attr);

参数:

cond:要操作的条件变量。

attr:设置条件变量属性。

返回值:

成功:返回0。

失败:返回错误码。

唤醒一个等待线程

pthread_cond_signal

功能:通知条件变量，唤醒一个等待者。

函数原型: int pthread_cond_signal (pthread_cond_t *cond);

参数:

cond:要操作的条件变量(条件变量指针)。

返回值:

成功:返回0。

失败:返回错误码。

唤醒所有等待该条件变量的线程

pthread_cond_broadcast

功能:广播条件变量。

函数原型: int pthread_cond_broadcast (pthread_cond_t *cond);

参数:

cond:要操作的条件变量。

返回值:

成功:返回0。

失败:返回错误码。

等待条件变量/超时被唤醒

pthread_cond_timedwait

功能:等待条件变量cond被唤醒，直到由一个信号或广播，或到绝对超时时间abstime，才唤醒该线程。

函数原型:int pthread_cond_timedwait (pthread_cond_t cond, pthread_mutex_t mutex, const struct timespec *abstime);

参数：

cond:要操作的条件变量:

mutex:互斥量。

返回值:

成功:返回0。

失败:返回错误码。

等待条件变量被唤醒

pthread_cond_wait

功能:等待条件变量cond被唤醒(由一个信号或广播)。

函数原型:int pthread_cond_wait (pthread_cond_t cond, pthread_mutex_t mutex);

参数:

cond:要操作的条件变量。

mutex:互斥量。

返回值:

成功:返回0。

失败:返回错误码。

释放/销毁条件变量

pthread_cond_destroy

功能:销毁条件变量。

函数原型:int pthread_cond_destroy (pthread_cond_t *cond);

参数:

cond:要销毁的条件变量。

返回值:

成功:返回0。

失败:返回错误码。

示例：

个人理解，条件变量会为临界资源创建两道防线，第一道防线为进入等待唤醒前，第二道为进入临界区前。

条件变量与互斥量的结合。

进入到第一道防线时，pthread_mutex_lock对互斥量加锁(P操作)。

进入到第一道防线后，也就是等待被唤醒前，pthread_cond_wait首先会先将当前线程挂起，然后解锁互斥量(V操作)。

被唤醒时，pthread_cond_wait首先对互斥量加锁，然后线程才被唤醒(第二道防线也突破)，执行完临界区中的代码后，再次解锁。

如下图示中，注意:

我们默认该进程有两个额外创建的线程，线程1首先执行。

图中仅示例线程1和线程2分别执行一次。

#include <stdio.h>
#include <pthread.h>
pthread_mutex_t mutex;//互斥量
pthread_cond_t cond;//条件变量
void *thread1(void *arg){

    while (1) {
        printf("thread1 is running\n");
        pthread_mutex_lock(&mutex);//加锁
        pthread_cond_wait(&cond, &mutex);//等待时挂起，然后开锁，被唤醒时，先加锁，然后再唤醒(即执行下方代码)。。
        printf("thread1 applied the condition\n");
        pthread_mutex_unlock(&mutex);//开锁
        sleep(4);
    }
}
void *thread2(void *arg){
    while (1) {
        printf("thread2 is running\n");
        pthread_mutex_lock(&mutex);//加锁
        pthread_cond_wait(&cond, &mutex);//等待时挂起，然后开锁，被唤醒时，先加锁，然后再唤醒(即执行下方代码)。
        printf("thread2 applied the condition\n");
        pthread_mutex_unlock(&mutex);//开锁
        sleep(2);
    }
}
int main(){
    pthread_t thid1, thid2;
    printf("condition variable study!\n");
    pthread_mutex_init(&mutex, NULL);//互斥量初始化
    pthread_cond_init(&cond, NULL);//条件变量初始化
    pthread_create(&thid1, NULL, (void *)thread1, NULL);//线程1创建
    pthread_create(&thid2, NULL, (void *)thread2, NULL);//线程2创建
    do {
        pthread_cond_signal(&cond);//唤醒一个等待线程
       sleep(1);
    } while (1);
    return 0;
}

目录CONTENT

【操作系统】线程的使用

线程

为什么使用线程?

什么是线程？

线程的优缺点

线程的应用场合

线程的使用

线程的创建

线程的终止

等待指定线程结束

使用线程程序的编译

线程的同步与互斥

信号量

什么是信号量？

信号量的初始化

信号量的P操作

信号量的V操作

信号量的删除

互斥量

什么是互斥量?

互斥量的初始化

互斥量的获取

互斥量的删除

线程的条件变量

什么是条件变量？

条件变量初始化

唤醒一个等待线程

唤醒所有等待该条件变量的线程

等待条件变量/超时被唤醒

等待条件变量被唤醒

释放/销毁条件变量

评论区