侧边栏壁纸
  • 累计撰写 278 篇文章
  • 累计创建 3 个标签
  • 累计收到 1 条评论

目 录CONTENT

文章目录

【操作系统】线程的使用

xuanxuan
2022-08-28 / 0 评论 / 0 点赞 / 8 阅读 / 16785 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2024-02-14,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

线程

为什么使用线程?

  • 使用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
  • 功能:等待指定线程结束,并获取该线程的返回值。
  • 函数原型: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;
}

image-20220827105611636


线程的同步与互斥

  • 线程的互斥:
    • 指某一资源同一时间只允许一个访问者对其进行访问,具有唯一性和排它性。
    • 但互斥无法限制访问者对资源的访问顺序,即访问是无序的。
  • 线程的同步:
    • 指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。

  • 问题 :同一个进程内的各个线程,共享该进程的全局变量,如果多个线程同时对某个全局变量进行访问时,就可能导致竞态。
  • 解决办法:对临界区使用信号量、或互斥量。
  • 信号量和互斥量的选择:对于同步和互斥,使用信号量和互斥量都可以实现。使用时选择更符合情况的:
    • 如果要求最多只允许一个线程进入临界区,则使用互斥量。
    • 如果要求多个线程之间的执行顺序满足某个约束,则使用信号量。

信号量

什么是信号量?
  • 此时所指的"信号量"是指用于同一个进程内多个线程之间的信号量。即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;
}

image-20220827160636350


互斥量

什么是互斥量?

效果等同于初始值为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;
}

image-20220827170736489


线程的条件变量

什么是条件变量?

  • 与互斥锁不同,条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程,直到某种情况发生为止,通常条件变量和互斥锁一起使用
  • 条件变量使我们可以睡眠来等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:
    • 线程因等待"条件变量的条件成立"而被挂起;
    • 线程使"条件成立"(给出条件成立信号)。
  • 条件的检测是在互斥锁的保护下进行的。如果条件为假,一个线程自动阻塞(挂起),并释放等待状态改变的互斥锁。
  • 如果另一个线程改变了条件,它发信号给关联的条件变量,唤醒一个或多个等待它的线程,重新获得互斥锁,重新评价条件。
  • 如果两个进程共享可读写的内存,条件变量可以被用来实现这两个进程间的线程同步。

条件变量初始化

  • 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分别执行一次。

image-20220827205151298

#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;
}

image-20220828095243264


0

评论区