备案控制台
探索云世界
开发者社区 大数据与机器学习 文章 正文

多线程编程

2023-06-10 69
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
实时计算 Flink 版，5000CU*H 3个月
推荐场景：
实时发现最热Github项目
检索分析服务 Elasticsearch 版，2核4GB开发者规格 1个月
推荐场景：
数据可视化分析航班信息
大数据开发治理平台 DataWorks，不限时长
推荐场景：
Github实时数据分析与可视化
简介： 主要参考韦东山老师的文档，如果没基础，直接看文档，别看视频！！！学习中。。。

多线程编程

基本概念

进程：PID

线程：tid

线程号与进程号是表示线程和进程的唯一标识，但是对于线程号而言 ，其仅仅在其所属的进程上下文中才有意义。

获取线程号

#include <pthread.h>
#include <stdio.h>
int main()
{
   
   
    pthread_t tid = pthread_self();
    printf("tid = %lu\n",(unsigned long)tid);
    return 0;
}
编译：gcc Pthread_Text1.c -lpthread

创建线程

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

void *fun(void *arg)
{
   
   
    printf("pthread_New = %lu\n",(unsigned long)pthread_self());
}

int main()
{
   
   

    pthread_t tid1;
    int ret = pthread_create(&tid1,NULL,fun,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }

    /*tid_main 为通过pthread_self获取的线程ID，tid_new通过执行pthread_create成功后tid指向的空间*/
    printf("tid_main = %lu tid_new = %lu \n",(unsigned long)pthread_self(),(unsigned long)tid1);

    /*因线程执行顺序随机，不加sleep可能导致猪线程先执行，导致进程结束，无法执行到子线程*/
    sleep(1);

    return 0;
}

output:
book@100ask:~/my_source$ ./a.out
tid_main = 139951278651200 tid_new = 139951270156032
pthread_New = 139951270156032
#如果不加sleep(1)根本执行不到子线程，因为执行顺序是随机的，并不能保证哪个进程先执行，因此如果先执行主线程，就会直接导致无法执行子线程，输出如下
book@100ask:~/my_source$ ./a.out
tid_main = 139857541936960 tid_new = 139857533441792

如此可以说明，线程的执行顺序不受控制，且整个进程结束后所产生的线程也随之被释放

线程传参

第四个参数传递有地址传递方式和变量传递方式两种

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

void *fun1(void *arg)
{
   
   
    printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
}

void *fun2(void *arg)
{
   
   
    printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
}

int main()
{
   
   

    pthread_t tid1,tid2;
    int a = 50;
    //地址方式传递
    int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    // 值方式传递
    ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
    if(ret != 0){
   
   
        //相对于printf能输出更多的错误信息
        perror("pthread_create");
        return -1;
    }
    sleep(1);
    printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
    return 0;
}

注意这块传值的时候，如果是地址方式传值，当变量发生改变时候，其地址对应的变量也会发生改变，但是如果使用变量传值的时候，当指针指向的变量发生改变，其传入的变量值不会发生变化，如下例程：

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

void *fun1(void *arg)
{
   
   
    while(1){
   
   

        printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
        sleep(1);
    }
}

void *fun2(void *arg)
{
   
   
    while(1){
   
   

        printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
        sleep(1);
    }
}

int main()
{
   
   

    pthread_t tid1,tid2;
    int a = 50;
    int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    sleep(1);
    ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    while(1){
   
   
        a++;
        sleep(1);
        printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
    }
    return 0;
}
//下面输出的顺序是乱的，因为线程执行的顺序不受控制，注意值传递和地址传递的区别！！！

image-20230610164042177

传递多个参数：结构体

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

struct Stu{
   
   
    int Id;
    char Name[32];
    float Mark;
};

void *fun1(void *arg)
{
   
   
    struct Stu *tmp = (struct Stu *)arg;
    printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,tmp->Id,tmp->Name,tmp->Mark);

}

int main()
{
   
   

    pthread_t tid1,tid2;
    struct Stu stu;
    stu.Id = 10000;
    strcpy(stu.Name,"ZhangSan");//字符串拷贝
    stu.Mark = 94.6;

    int ret = pthread_create(&tid1,NULL,fun1,(void *)&stu);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,stu.Id,stu.Name,stu.Mark);
    sleep(1);
    return 0;
}

image-20230610164556622

线程的退出和回收

线程主动退出

image-20230610164832914

线程被动退出

image-20230610164855950

线程资源回收（阻塞方式）

image-20230610164934777

第一个参数为要回收线程的tid号，第二个参数为线程回收后接收线程传出的数据

线程资源回收（非阻塞方式）

image-20230610165039768

阻塞方式回收线程：

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

void *fun1(void *arg)
{
   
   
    static int tmp = 0;//必须要static修饰，为变量的生命周期做延续，否则pthread_join无法获取到正确的值
    //int tmp = 0;
    tmp = *(int *)arg;
    tmp+=100;
    printf("%s:Addr = %p tmp = %d\n",__FUNCTION__,&tmp,tmp);
    pthread_exit((void *)&tmp);
}


int main()
{
   
   

    pthread_t tid1;
    int a = 50;
    void *Tmp = NULL;
    int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    //这里不用sleep，是因为pthread_join函数具备阻塞他行，直到成功收回线程才会冲破阻塞，因此不用考虑主线程执行到最后结束线程的情况。
    pthread_join(tid1,&Tmp);//&Tmp就相当于接收线程传出的数据，上面fun1传出的数据
    printf("%s:Addr = %p Val = %d\n",__FUNCTION__,Tmp,*(int *)Tmp);
    return 0;
}

通过阻塞方式回收线程几乎规定了线程回收的顺序，若最先回收的线程未退出，则一直会被阻塞，导致后续先退出的线程无法及时的回收。

非阻塞方式回收线程

通过函数pthread_tryjoin_np，使用非阻塞回收，线程可以根据退出先
后顺序自由的进行资源的回收。

多个线程可以指向同一个回调函数

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun(void *arg)
{
   
   
    printf("Pthread:%d Come !\n",(int )(long)arg+1);
    pthread_exit(arg);
}
int main()
{
   
   
    int ret,i,flag = 0;
    void *Tmp = NULL;
    pthread_t tid[3];
    for(i = 0;i < 3;i++){
   
   
        ret = pthread_create(&tid[i],NULL,fun,(void *)(long)i);
        if(ret != 0){
   
   
            perror("pthread_create");
            return -1;
        }
    }
    while(1){
   
   
        for(i = 0;i <3;i++){
   
   
            if(pthread_tryjoin_np(tid[i],&Tmp) == 0){
   
   
                printf("Pthread : %d exit !\n",(int )(long )Tmp+1);
                flag++;    
            }
        }
        if(flag >= 3) break;
    }
    return 0;
}

image-20230610171851090

pthread_cancel主动结束线程

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    // 第一个进程为死循环睡眠状态
    printf("Pthread:1 come!\n");
    while (1)
    {
   
   
        sleep(1);
    }
}

void *fun2(void *arg)
{
   
   
    printf("Pthread:2 come!\n");
    pthread_cancel((pthread_t)(long)arg); // 退出第一个进程，传入第一个线程的线程号
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret, i, flag = 0;
    void *Tmp = NULL;
    pthread_t tid[2];
    ret = pthread_create(&tid[0], NULL, fun1, NULL);
    if (ret != 0)
    {
   
   
        perror("pthread_create");
        return -1;
    }
    // 确保必须线程1先执行，因为线程是无序的，因此加入睡眠控制函数控制顺序
    sleep(1);
    ret = pthread_create(&tid[1], NULL, fun2, (void *)tid[0]);
    if (ret != 0)
    {
   
   
        perror("pthread_create");
        return -1;
    }
    while (1)
    {
   
   
        for (i = 0; i < 2; i++)
        {
   
   
            if (pthread_tryjoin_np(tid[i], NULL) == 0)
            {
   
    // 尝试回收线程
                printf("Pthread : %d exit !\n", i + 1);
                flag++;
            }
        }
        if (flag >= 2)
            break;
    }
    return 0;
}

线程的控制

多线程编程临界资源访问

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>


int Num = 0;

void *fun1(void *arg)
{
   
   
    while(Num < 3){
   
   
        Num++;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_exit(NULL);
}

void *fun2(void *arg)
{
   
   
    while(Num > -3){
   
   
        Num--;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2;
    ret = pthread_create(&tid1,NULL,fun1,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    return 0;
}

上述代码会产生临界资源竞争，pthread线程引入互斥锁来解决临界资源访问。通过对临界资源加锁来保护资源只能被单个线程操作，操作结束后解锁，其余线程才可获得操作权。

互斥锁API

初始化互斥量

image-20230610204449194

互斥量加锁/解锁

image-20230610204601991

互斥量加锁（非阻塞方式）

image-20230610204828330

互斥量解锁（非阻塞方式）

image-20230610205052585

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

pthread_mutex_t mutex;

int Num = 0;

void *fun1(void *arg)
{
   
   
    pthread_mutex_lock(&mutex);    //加锁
    while(Num < 3){
   
   
        Num++;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);    //解锁
    pthread_exit(NULL);    //退出线程
}

void *fun2(void *arg)
{
   
   
    pthread_mutex_lock(&mutex);    //加锁
    while(Num > -3){
   
   
        Num--;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);        //解锁
    pthread_exit(NULL);    //退出线程
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2;
    ret = pthread_mutex_init(&mutex,NULL);    //初始化互斥量
    if(ret != 0){
   
   
        perror("pthread_mutex_init");
        return -1;
    }
    ret = pthread_create(&tid1,NULL,fun1,NULL);    //创建线程
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);    //创建线程
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);    //等待线程结束
    pthread_join(tid2,NULL);    //等待线程结束
    pthread_mutex_destroy(&mutex);    //销毁互斥量
    return 0;
}
//输出结果如下：

image-20230610205945019

上面代码加入互斥量，保证临界变量在某一时刻只能被某一线程控制，实现了对临界资源的控制。

线程加锁在循环内和循环外的情况：

对于单核机器，执行结果没有区别。当多核机器执行代码时候，可能会发生“抢锁现象”，取决于操作系统底层的实现。

多线程执行顺序控制

信号量：解决线程执行顺序

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    printf("%s:Pthread Come!\n",__FUNCTION__);
    pthread_exit(NULL);
}

void *fun2(void *arg)
{
   
   
    printf("%s:Pthread Come!\n",__FUNCTION__);
    pthread_exit(NULL);
}

void *fun3(void *arg)
{
   
   
    printf("%s:Pthread Come!\n",__FUNCTION__);
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2,tid3;
    ret = pthread_create(&tid1,NULL,fun1,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid3,NULL,fun3,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    return 0;
}

image-20230610210656769

当多次执行该函数次序是无序的，线程之间的竞争无法控制，使用信号量使得线程顺序可控

信号量API简述

互斥量用来防止多个线程同时访问某个临界资源

信号量起通知作用，线程A在等待某事，线程B完成这件事后就可以发信号给线程A

初始化信号量

image-20230610211339351

信号量P/V操作

image-20230610211411655

信号量申请（非阻塞方式）

image-20230610211535236

与上面的sem_wait一致，区别在于此函数非阻塞

信号量销毁

image-20230610211620935

程序实例

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <semaphore.h>

sem_t sem1,sem2,sem3;//申请的三个信号量变量

void *fun1(void *arg)
{
   
   
    sem_wait(&sem1);//因sem1本身有资源，所以不被阻塞 获取后sem1-1 下次会会阻塞
    printf("%s:Pthread Come!\n",__FUNCTION__);
    sem_post(&sem2);// 使得sem2获取到资源
    pthread_exit(NULL);
}

void *fun2(void *arg)
{
   
   
    sem_wait(&sem2);//因sem2在初始化时无资源会被阻塞，直至14行代码执行 不被阻塞 sem2-1 下次会阻塞
    printf("%s:Pthread Come!\n",__FUNCTION__);
    sem_post(&sem3);// 使得sem3获取到资源
    pthread_exit(NULL);
}

void *fun3(void *arg)
{
   
   
    sem_wait(&sem3);//因sem3在初始化时无资源会被阻塞，直至22行代码执行 不被阻塞 sem3-1 下次会阻塞
    printf("%s:Pthread Come!\n",__FUNCTION__);
    sem_post(&sem1);// 使得sem1获取到资源
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2,tid3;
    ret = sem_init(&sem1,0,1);  //初始化信号量1 并且赋予其资源
    if(ret < 0){
   
   
        perror("sem_init");
        return -1;
    }
    ret = sem_init(&sem2,0,0); //初始化信号量2 让其阻塞
    if(ret < 0){
   
   
        perror("sem_init");
        return -1;
    }
    ret = sem_init(&sem3,0,0); //初始化信号3 让其阻塞
    if(ret < 0){
   
   
        perror("sem_init");
        return -1;
    }
    ret = pthread_create(&tid1,NULL,fun1,NULL);//创建线程1
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);//创建线程2
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid3,NULL,fun3,NULL);//创建线程3
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    /*回收线程资源*/
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);

    /*销毁信号量*/
    sem_destroy(&sem1);
    sem_destroy(&sem2);
    sem_destroy(&sem3);

    return 0;
}

image-20230610212006787

加入信号量使得线程执行顺序变为可控的

线程处理函数中，每个线程通过sem_wait函数来等待资源，发生阻塞。信号量1初始值有资源，可以执行线程1的逻辑。执行完sem_wait函数后会导致sem1-1使得下一次该线程被阻塞（为啥？看上面解释变成0了？）

条件变量（同步机制）

用来通知其他线程条件满足了，一般用来通知对方共享数据的状态信息，条件变量结合互斥量来使用。

创建和销毁条件变量

image-20230610212815405

等待条件变量

image-20230610212845985

通知条件变量

image-20230610212914644

ps -T #查看进程信息
kill -9 进程号 #停止对应进程号进程

总结

image-20230610215213761

image-20230610215241866

image-20230610215309038

image-20230610215329413

image-20230610215349268

文章标签：
API
王先森Vicent
目录
相关文章
Echo_Wish
|
7月前
|
开发框架 Java .NET
C# 多线程编程二
C# 多线程编程二
Echo_Wish
57 0
游客3bfkcht77micg
|
5月前
|
Java Linux C++
多进程编程 VS 多线程编程
多进程编程 VS 多线程编程
游客3bfkcht77micg
32 0
多进程编程 VS 多线程编程
Echo_Wish
|
7月前
|
开发框架 .NET 调度
C# 多线程编程一
C# 多线程编程
Echo_Wish
45 0
kaixin_AA
|
11月前
|
SQL 开发框架 负载均衡
【C#】多线程编程
多线程是现代程序设计中非常重要的一个概念，可以利用多线程在同一时间内执行多个任务，从而提高程序的效率和性能。在本篇博客中，我们将探讨C#中的多线程编程。
kaixin_AA
94 0
互联网小阿祥
|
12月前
|
Java
【并发编程】线程间的通信
【并发编程】线程间的通信
互联网小阿祥
50 0
JanYork|小简
|
Web App开发 存储 安全
Java并发编程之多线程
我们首先，先要了解什么是进程，什么是线程。
JanYork|小简
87 0
游客tmj4hgt7bfvas
|
安全 Java
【多线程学习笔记4】线程同步
【多线程学习笔记4】线程同步
游客tmj4hgt7bfvas
99 0
double2li
|
C++ 编译器 Windows
C++多线程编程（三）线程间通信
多线程编程之三——线程间通讯作者：韩耀旭 原文地址：http://www.vckbase.com/document/viewdoc/?id=1707   七、线程间通讯 　　一般而言,应用程序中的一个次要线程总是为主线程执行特定的任务,这样,主线程和次要线程间必定有一个信息传递的渠道,也就是主线程和次要线程间要进行通信。
double2li
2208 0
煜月
|
Java Go
多线程与高并发编程之基础篇
多线程与高并发编程基础
煜月
118 0
多线程与高并发编程之基础篇
markfork
|
Java
Java并发编程基础-线程间通信
章节目录 volatile 与 synchronized 关键字 等待/通知机制 等待/通知经典范式 管道输入/输出流 Thread.join() 的 使用 1. volatile 与 synchronized 关键字 线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一行一行的执行，直到终止。
markfork
996 0

大数据与机器学习

热门文章

最新文章

  • 1
    阿里巴巴飞天大数据平台MaxCompute（原名ODPS）全套攻略（持续更新20200109）
  • 2
    一文解析 ODPS SQL 任务优化方法原理
  • 3
    给技术新人的ODPS优化建议
  • 4
    odps是什么?
  • 5
    【玩转数据系列二】机器学习应用没那么难，这次教你玩心脏病预测
  • 6
    阿里云MaxCompute（大数据）公开数据集---带你玩转人工智能
  • 7
    空格App亿元A轮融资背后：云上多场景技术架构实践与经验
  • 8
    Kibana：数据分析的可视化利器
  • 9
    Python+大数据计算平台，PyODPS架构手把手教你搭建
  • 10
    干货：解码OneData，阿里的数仓之路。
  • 1
    Golang深入浅出之-Go语言中的并发安全容器：sync.Map与sync.Pool
    9
  • 2
    Golang深入浅出之-Goroutine泄漏检测与避免：pprof与debug包
    15
  • 3
    Golang深入浅出之-Go语言中的CSP模型：深入理解并发哲学
    14
  • 4
    Kylin使用心得：从入门到进阶的探索之旅
    14
  • 5
    大数据组件之Storm简介
    9
  • 6
    Gradformer: 通过图结构归纳偏差提升自注意力机制的图Transformer
    12
  • 7
    文本挖掘基础入门指南
    20
  • 8
    Golang深入浅出之-Goroutine泄漏检测与避免：pprof与debug包
    10
  • 9
    Golang深入浅出之-Go语言中的CSP模型：深入理解并发哲学
    7
  • 10
    Golang深入浅出之-Go语言中的并发模式：Pipeline、Worker Pool等
    12

    • 相关电子书

    更多
  • 多线程
  • 原子变量与内存模型
  • 低代码开发师（初级）实战教程
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考