Linux多线程并发运行原理+代码例程详解

最新推荐文章于 2023-06-03 11:00:00 发布
最新推荐文章于 2023-06-03 11:00:00 发布
阅读量2k 收藏 26
点赞数 1
分类专栏： i.MX6 文章标签： 多线程 嵌入式 linux 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szm1234/article/details/115332962
版权

文章目录

线程创建和退出

原理

在这里插入图片描述

代码

交叉编译

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


/*thread1*/
void thread1(void)
{
    int i = 0;
    for(i = 0; i < 6; i++) {
        printf("This is a pthread1. \n");
        if(i == 2){
            pthread_exit(0);
        }
        sleep(1);
    }
}


/*thread2*/
void thread2(void)
{
    int i;
    for(i = 0; i < 3; i++){
        printf("This is a pthread2. \n");   
    }
    pthread_exit(0);
}

/*main*/
int main(void)
{
    pthread_t id1, id2;
    int i,ret;
    /*create thread1*/
    ret = pthread_create(&id1, NULL, (void *) thread1, NULL);
    if(ret != 0){
        printf("Create pthread1 error!\n");
        exit(1);
    }
    /*create thread2*/
    ret = pthread_create(&id2, NULL, (void *) thread2, NULL);
    if(ret != 0) {
        printf("Create pthread2 error!\n");
        exit(1);
    }
    /*wait for thread to end*/
    pthread_join(id1, NULL);
    pthread_join(id2, NULL);
    exit(0);

    return 0;
}

执行

$CC thread_test.c

结果报错
在这里插入图片描述
出现编译错误undefined reference to ‘pthread_create’。由于pthread库不是标准linux库， 所以出错。 找不到函数库，通过静态调用，-lpthread，就可以编译通过

 $CC thread_test.c -o thread_test.0 -lpthread

在这里插入图片描述
然后通过scp命令发送可执行文件到开发板

scp thread_test root@192.168.0.232:/tmp

在这里插入图片描述

结果

在开发板中执行
在这里插入图片描述

线程属性修改

原理

在这里插入图片描述

代码

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

/*thread1*/
void thread1(void)
{
    int i = 0;
    for(i = 0; i < 6; i++) {
        printf("This is a pthread1. \n");
        if(i == 2){
            pthread_exit(0);
        }
        sleep(1);
    }
}


/*thread2*/
void thread2(void)
{
    int i;
    while(1){
        for(i = 0; i < 3; i++){
            printf("This is a pthread2. \n");  
            sleep(1); 
        }
    }
    
    /* void pthread_exit(void *retval)
     * Retval：pthread_exit()调用者线程的返回值，可由其他函数如pthread_join 来检索获取 
     */
    pthread_exit(0);
}

/*main*/
int main(void)
{
    pthread_t id1, id2;
    int i,ret;
    pthread_attr_t attr;

    /*初始化线程 */
    pthread_attr_init(&attr);

    /*设置线程绑定属性*/
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

    /*设置线程分离属性*/
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

    /* create thread1 创建线程
     * int pthread_create ((pthread_t *thread, pthread_attr_t *attr,void *(*start_routine)(void *), void *arg)) 
     * thread：线程标识符
     * attr：线程属性设置
     * start_routine：线程函数的起始地址
     * arg：传递给start_routine的参数
     * return：成功：0 出错：-1
     */
    ret=pthread_create(&id1,&attr,(void *) thread1,NULL);
    if(ret != 0){
        printf("Create pthread1 error!\n");
        exit(1);
    }
    /*create thread2*/
    ret = pthread_create(&id2, NULL, (void *) thread2, NULL);
    if(ret != 0) {
        printf("Create pthread2 error!\n");
        exit(1);
    }
    /*wait for thread to end*/
    /* int pthread_join ((pthread_t th, void **thread_return))
     * th：等待线程的标识符
     * thread_return：用户定义的指针，用来存储被等待线程的返回值（不为NULL时）
     * return：成功：0 出错：-1
     */
    // pthread_join(id1, NULL);                                        // pthread_join将当前线程挂起，等待线程的结束
    pthread_join(id2, NULL);
    // exit(0);                                                        // 所有线程都终止

    return 0;
}

这次不放在嵌入式开发板上运行了，所以就用gcc编译了

 gcc thread_test2.c -o thread_test2 -lpthread

结果

直接在wsl中运行编译好的可执行文件thread_test2
在这里插入图片描述
因为有个while死循环的存在，所以程序就会一直运行下去，我们ctrl+c来结束打印，然后输入free

使用“free”命令查看内存使用情况

这是程序运行之前的内存使用情况uesd
在这里插入图片描述
这是程序运行之后的内存使用情况used
在这里插入图片描述

互斥锁

原理

在这里插入图片描述

代码

/*
 * 使用互斥锁来实现对变量lock_var 的加一、打印操作
 */

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;                                              // 创建快速互斥锁
int lock_var;
time_t end_time;

void pthread1(void *arg);
void pthread2(void *arg);

int main(int argc, char *argv[])
{
    pthread_t id1,id2;
    pthread_t mon_th_id;
    int ret;

    end_time = time(NULL) + 10;

    /* 互斥锁初始化
     * int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)
     * Mutex：互斥锁
     * Mutexattr:PTHREAD_MUTEX_INITIALIZER：创建快速互斥锁;PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP：创建递归互斥锁;PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP：创建检错互斥锁
     * return：成功：0 出错：-1
     */
    pthread_mutex_init(&mutex, NULL);

    /*创建两个线程*/
    ret = pthread_create(&id1, NULL, (void *)pthread1, NULL);
    if(ret != 0){
        perror("pthread cread1");
    }
    ret = pthread_create(&id2, NULL, (void *)pthread2, NULL);
    if(ret != 0){
        perror("pthread cread2");
    }
    pthread_join(id1, NULL);
    pthread_join(id2, NULL);
    exit(0);
}

void pthread1(void *arg)
{
    int i;
    while(time(NULL) < end_time){
        /* 
         * int pthread_mutex_lock(pthread_mutex_t *mutex,)
           int pthread_mutex_trylock(pthread_mutex_t *mutex,)
           int pthread_mutex_unlock(pthread_mutex_t *mutex,)
           int pthread_mutex_destroy(pthread_mutex_t *mutex,)
         * Mutex：互斥锁
         * return:成功：0 出错：-1
         */
        /*互斥上锁*/
        if(pthread_mutex_lock(&mutex) != 0){                            
            perror("pthread_mutex_lock");
        }else{
            printf("pthread1:pthread1 lock the variable\n");
        }

        for(i = 0; i < 0; i++){
            sleep(1);
            lock_var++;
        }
        /*互斥锁解锁*/
        if(pthread_mutex_unlock(&mutex) != 0){
            perror("pthread_mutex_unlock\n");
        }else{
            printf("pthread1:pthread1 unlock the variable\n");
        }
        sleep(1);
    }
}

void pthread2(void *arg)
{
    int nolock = 0;
    int ret;
    while(time(NULL) < end_time){
        /*测试互斥锁*/
        ret = pthread_mutex_trylock(&mutex);
        if(ret == EBUSY){
            printf("pthread2:the variable is locked by pthread1\n");
        }else{
            if(ret != 0){
                perror("pthread_mutex_trylock");
                exit(1);
            }else{
                printf("pthread2:pthread2 got lock. The variable is %d\n", lock_var);
            }
            /*互斥锁解锁*/
            if(pthread_mutex_unlock(&mutex) != 0){
                perror("pthread_mutex_unlock");
            }else{
                printf("pthread2:pthread2 unlock the variable\n");
            }
        }
        sleep(3);
    }
}

代码是什么意思呢？
在这里插入图片描述
两个线程并发，线程一定时while循环，锁定时候线程二检测到上锁然后不运行服务函数，检测到解锁后运行服务函数输出

编译代码
在这里插入图片描述

结果

运行可执行文件
在这里插入图片描述

信号量线程控制原理

在这里插入图片描述

使用信号量线程互斥

使用同一个信号量sem，sem初始值设置为0，进程一执行P操作，sem-1=-1，所以该进程就将阻塞直到信号量sem大于等于0为止。

代码

/*
 * 信号量线程控制
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/ipc.h>
#include <semaphore.h>

int lock_var;
time_t end_time;
sem_t sem;

void pthread1(void *arg);
void pthread2(void *arg);

int main(int argc, char *argv[])
{
    pthread_t id1, id2;
    pthread_t mon_th_id;
    int ret;
    end_time = time(NULL) + 30;

    /*初始化信号量为1*/
    ret = sem_init(&sem, 0, 1);
    if(ret != 0){
        perror("sem_init");
    }

    /*创建两个线程*/
    ret = pthread_create(&id1, NULL, (void *)pthread1, NULL);
    if(ret != 0){
        perror("pthread cread1");
    }
    ret = pthread_create(&id2, NULL, (void *)pthread2, NULL);
    if(ret != 0){
        perror("pthread cread2");
    }
    
    pthread_join(id1, NULL);
    pthread_join(id2, NULL);

    exit(0);
}

void pthread1(void *arg)
{
    int i;
    while(time(NULL) < end_time){
        /*信号量减一,p操作*/
        sem_wait(&sem);
        for(i = 0; i < 2; i++){
            sleep(1);
            lock_var++;
            printf("lock_var = %d\n", lock_var);
        }
        printf("pthread1:lock_var = %d\n", lock_var);

        /*信号量加一，v操作*/
        sem_post(&sem);
        sleep(1);
    }
}

void pthread2(void *arg)
{
    int nolock = 0;
    int ret;
    while(time(NULL) < end_time){
        /*信号量减一，p操作*/
        sem_wait(&sem);
        printf("pthread2:pthread1 got lock; lock_var = %d\n", lock_var);

        /*信号量加一，v操作*/
        sem_post(&sem);
        sleep(3);
    }
}

在这里插入图片描述

结果

运行结果如图所示
在这里插入图片描述

在输出的结果中，可以很清晰的看到，进程一执行了P操作后，线程二就被阻塞了不能执行，等待线程一执行完for循环过了2s之后，线程一执行V操作，sem=0，然后再等待一秒钟

sem现在大于等于0，所以该进程具有公共资源的访问权限，线程二可以执行V操作修改sem的值了，sem=-1，线程之间又发生了互斥，线程二执行输出，然后sleep 3秒钟。

使用信号量线程同步

在这里插入图片描述

代码

/*
 * 通过两个信号量来实现两个线程间的同步
 * 程序先运行线程二，再运行线程一
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/ipc.h>
#include <semaphore.h>

int lock_var;
time_t end_time;
sem_t sem1, sem2;

void pthread1(void *arg);
void pthread2(void *arg);

int main(int argc, char *argv[])
{
    pthread_t id1, id2;
    pthread_t mon_th_id;
    int ret;
    end_time = time(NULL) + 30;

    /*初始化两个信号量，一个信号量为1，一个信号量为0*/
    ret = sem_init(&sem1, 0, 1);
    ret = sem_init(&sem2, 0, 0);
    if(ret != 0){
        perror("sem_init");
    }

    /*创建两个线程*/
    ret = pthread_create(&id1, NULL, (void *)pthread1, NULL);
    if(ret != 0){
        perror("pthread cread1");
    }
    ret = pthread_create(&id2, NULL, (void *)pthread2, NULL);
    if(ret != 0){
        perror("pthread cread2");
    }

    pthread_join(id1, NULL);
    pthread_join(id2, NULL);

    exit(0);
}

void pthread1(void *arg)
{
    int i;
    while(time(NULL) < end_time){
        /*P操作信号量sem2 = 0 信号量-1*/
        sem_wait(&sem2);//现在sem2=-1，该线程阻塞，直到sem2的值大于等于零为止，也就是进程二执行V操作sem2=0
        for(i = 0; i < 2; i++){
            sleep(1);
            lock_var++;
            printf("lock_var = %d\n", lock_var);
        }
        printf("pthread1:lock_var = %d\n", lock_var);

        /*V 操作信号量sem1 = 0 +1*/
        sem_post(&sem1);//sem1 = 1
        sleep(1);
    }
}

void pthread2(void *arg)
{
    int nolock = 0;
    int ret;
    while(time(NULL) < end_time){
        /*P 操作信号量sem1 = 1 信号量-1*/
        sem_wait(&sem1);//现在sem1=0 该线程具有公共资源的访问权限，执行
        printf("pthread2:pthread1 got lock; lock_var = %d\n", lock_var);

        /*V 操作信号量sem2 = -1 +1*/
        sem_post(&sem2);//现在sem2=0，所以线程一就可以运行了
        sleep(3);
    }
}

结果

从以下结果中可以看出，该程序确实实现了先运行线程二，再运行线程一。
在这里插入图片描述

小结分析

对于线程一和线程二都在3s 的一个周期内进行并行的操作，因为有两个信号量，所以可以分别控制
在这里插入图片描述

在第一个时间中，sem2 = -1，sem1 = 0；所以线程二可以执行，线程一此时被阻塞， 需要等待sem2 >= 0 的状态。线程二执行了自己的输出pthread2:pthread1 got lock; lock_var = 0，然后执行V操作，sem2 = 0，这时候线程一满足了执行的条件，执行设定的输出lock_var = 1。这时候线程二也在运行，执行sleep(3)，也就是延迟3s，只是这个过程没有了其他的输出。

在第二个时间中，因为满足了sem2 >= 0 的条件，所以继续执行lock_var = 2，并且结束了for循环，执行输出pthread1:lock_var = 2，而于此同时线程二依然在sleep中。

在第三个时间中，线程一执行了V操作，sem1 = 1，时间也来到了第三秒，一个时间周期完成。

“生产者消费者”实验

问题分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码

/*
 * 有一个有限缓冲区和两个线程：生产者和消费者。他们分别把产品放入缓冲区和从缓冲
   区中拿走产品。当一个生产者在缓冲区满时必须等待，当一个消费者在缓冲区空时页必须等
   待。
 * 这里使用3个信号量，其中两个信号量avail和full分别用于解决生产者和消费者线程之
   间的同步问题，mutex是用于这两个线程之间的互斥问题。其中avail初始化为N（有界缓冲 
   区的空单元数），mutex 初始化为1，full初始化为0。
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <fcntl.h>
#include <string.h>

#define FIFO        "myfifo"
#define N           5

int lock_var = 0;
int fd;
char buf_r[100];

sem_t mutex, full, avail;
time_t end_time;

void productor(void *arg);
void consumer(void *arg);
void pthread1(void *arg);
void pthread2(void *arg);

/*主函数*/
int main(int argc, char *argv[])
{
    pthread_t id1, id2;
    pthread_t mon_th_id;

    int ret;

    end_time = time(NULL) + 30;

    /*创建有名管道*/
    if((mkfifo(FIFO, O_CREAT|O_EXCL) < 0) && (errno != EEXIST)){
        printf("cannot create fifoserver\n");
    }
    printf("Preparing for reading bytes...\n");
    memset(buf_r, 0, sizeof(buf_r));

    /*打开管道*/
    fd = open(FIFO, O_RDWR|O_NONBLOCK, 0);                          // 新建文件myfifo
    if(fd == -1){
        perror("open");
        exit(1);
    }

    /*初始化互斥信号量为1*/
    ret = sem_init(&mutex, 0, 1);

    /*初始化avail信号量为N*/
    ret = sem_init(&avail, 0, N);

    /*初始化full信号量为0*/
    ret = sem_init(&full, 0, 0);
    if(ret != 0){
        perror("sem_init");
    }

    /*创建两个线程*/
    ret = pthread_create(&id1, NULL, (void *)productor, NULL);
    if(ret != 0){
        perror("pthread cread1");
    }

    ret = pthread_create(&id2, NULL, (void *)consumer, NULL);
    if(ret != 0){
        perror("pthread cread2");
    }

    pthread_join(id1, NULL);
    pthread_join(id2, NULL);

    exit(0);
}

/*生产者线程*/
void productor(void *arg)
{
    int i, nwrite;
    while(time(NULL) < end_time){
        /*P操作信号量avail和mutex*/
        sem_wait(&avail);                                           // avail= N-1   
        sem_wait(&mutex);                                           // mutex= 1-1 =0 
        /*生产者写入数据*/
        if((nwrite = write(fd, "hello", 5)) == -1){                 // 字符数据“hello”写入到fd文件中
            if(errno == EAGAIN){
                printf("The FIFO has not been read yet. Please try later\n");
            }
        }else{
                printf("write hello to the FIFO\n");
        }

        /*V操作信号量full和mutex*/
        sem_post(&full);                                            // full =  -1+1 = 0  消费者线程可以运行了
        sem_post(&mutex);                                           // mutex =  0+1 = 1
        sleep(1);
    }
}

/*消费者线程*/
void consumer(void *arg)
{
    int nolock = 0;
    int ret, nread;
    while(time(NULL) < end_time){
        /*P操作信号量full和mutex*/
        sem_wait(&full);                                            // full  = 0-1 = -1 阻塞等待生产者写入完成 full>=0
        sem_wait(&mutex);                                           // mutex = 1-1 = 0
        memset(buf_r, 0, sizeof(buf_r));                            // buf_r 置零
        if((nread = read(fd, buf_r, 100)) == -1){                   // 读取fd中消费者写入的数据到buf_r中
            if(errno == EAGAIN){
                printf("no data yet\n");
            }
        }
        printf("read %s from FIFO\n", buf_r);                       // 输出buf_r

        /*V操作信号量avail和mutex*/
        sem_post(&avail);                                           // avail = N
        sem_post(&mutex);                                           // mutex = 0+1 = 1
        sleep(1);
    }
}

结果分析

编译之后执行，得到了预期的结果

在这里插入图片描述

“逛丢一只鞋”
关注
  • 1
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux线程的实质
02-23
线程与进程的比较进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。在串行程序基础上引入线程和进程是为
linux 多线程高并发,多线程与高并发01-线程基础（一）
weixin_33474071的博客
05-07 306
基础概念进程和线程进程是程序运行资源分配的最小单位线程是CPU调度的最小单位，必须依赖于进程二存在任何程序都必须创建线程，Java程序的main函数就会创建一个主线程Linux下一个进程最多只能开1000个线程，新线程分配栈空间1MCPU核心数和线程数关系多线程: Simultaneous Multithreading，简称SMT，让同一个处理器上的多个线程同步执行并共享处理器的执行资源。核心数、...
Linux线程
incipe
06-23 639
一. 线程 pthread不是linux下默认的库，有可能需要安装。 sudo apt-get install glibc-doc sudo apt-get install manpages-posix-dev 通过man pthread_creat查看man pages中关于pthread的手册。 #include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*star
Linux线程的创建和基本操作
m0_72442663的博客
03-16 941
Linux系统线程的基本操作
Linux中的线程（一）-- 线程的创建
uleemos的博客
05-08 1621
Linux 中的线程被称为“轻量级进程”（Lightweight Process，LWP），它是在进程内部运行的一种“子进程”。与传统的进程不同，线程共享相同的虚拟地址空间和其他资源，例如打开的文件、信号处理程序和用户 ID 等。
linux并发与竞争原理
m0_64792825的博客
02-03 66
线程锁的使用
Linux下多线程的操作
林夕07
07-30 991
线程是轻量级的进程（LWP:light weight pocess），在Linux环境下线程的本质仍然是进程。在计算机上运行的程序是一组指令及指令参数的组合，指令按照既定的逻辑控制计算机运行。操作系统会以进程为单位，分配系统资源，可以这样理解，进程是资源分配的最小单位，线程是操作系统调度执行的最小单位。...
Linux线程编程（二）
qq_42882082的博客
06-07 530
二、线程相关API 注： 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以pthread_d打头的，要使用这些函数库，要通过引入头文件pthread.h，因为pthread的库不是linux系统的库，所以在进行编译的时候要加上-lpthread进行链接线程函数库。 同进程ID一样，线程ID是pid_t类型的变量，而且是用来唯一标识线程的一个整型变量，在linux当中如果你要查询系统中的线程，也有一条命令：ps -aL 在传统的UNIX进程模型中，每个进程只有一个控制线程，从概念上讲，这与基于
线程（Linux系统实现）
好好学习，天天向上
06-03 1115
本文讲述了什么是线程，以及在Linux系统下线程的相关操作
Linux 多线程开发（附有案例代码）
热爱数据库的小胖
07-15 5362
同一个程序中的所有线程均会独立执行相同程序，且共享同一份全局内存区域，其中包括初始化数据段、未初始化数据段，以及堆内存段。(传统意义上的UNIX进程只是多线程程序的一个特例,该进程只包含一个线程)调用fork()来创建进程的代价相对较高，即便利用写时复制技术，仍热需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着fork()调用在时间上的开销依然不菲。进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通信方式，在进程间进行信息交换。进程ID和父进程工D。..
linux多线程间使用共享内存例程，C++版本。
12-13
linux多线程间使用共享内存例程，C++版本。可用于大量数据的多线程共享。
红外遥控原理整理+自带例程+改进代码
12-18
nec编码的红外接收程序，带有原例程，改进代码为脉宽捕获解码
多线程操作_paintawe_多线程写入例程_
10-01
多线程写入例程，有清晰的文件说明，供学习参考
STM32F411开发板（原理图+PCB源文件+官方例程）
最新发布
09-18
STM32F411开发板原理图+PCB源文件+官方例程+开发板使用说明等 STM32F411开发板原理图+PCB源文件+官方例程+开发板使用说明等 STM32F411开发板原理图+PCB源文件+官方例程+开发板使用说明等 STM32F411开发板原理图+PCB...
完整版多线程例程－黑客帝国特效.rar
04-02
完整版多线程例程－黑客帝国特效.rar
pthread_create
狂飙的蜗牛
09-03 896
pthread_create
LINUX-并发程序设计线程篇
Ray的博客
11-11 452
线程的概念 进程 进程有独立的地址空间 Linux为每个进程创建task_struct 每个进程都参与内核调度，互不影响 线程 进程在切换时系统开销大 很多操作系统引入了轻量级进程LWP 同一进程中的线程共享相同地址空间 Linux不区分进程，线程（均会创建task_struct） 线程的特点 通常线程指的是共享相同地址空间的多个任务 使用多线程的好处 大大提高了任务切换的效率 避免了额外的TLB & cache的刷新 线程共享资源 线程私有资源 可执行的指令 线程
Linux高并发服务器开发—多线程
梅山
07-06 2696
连接已终止的线程 代码实现 间隔3S 回收子线程资源。 为什么pthread_join 要传递2级指针？好比说，int *a；修改这个数值，要传递一级指针。为了获得子线程退出时的返回值，所以join函数传入的是指向该返回值的指针，因为该返回值也是一个指针，所以传入的是二级指针。好比说 int a =10； 函数要对a进行改变，无法修改a的数值。所以类型为 同理： 函数要对a进行改变，无法修改a的数值。所以类型为 代码实例 线程分离之后再进行连接会出现error的情况。 取消某个线程 多次运行结
Linux操作系统之线程创建
qq_55703811的博客
01-11 1065
一、了解线程 二、线程的创建
使用多线程并行计算来加速warpAffine QTC++例程
05-25
对于warpAffine QTC++例程的并行化，可以使用OpenMP多线程库来实现。以下是一些可以尝试的步骤： 1. 引入OpenMP头文件，并启用OpenMP编译选项： ```c++ #include #pragma omp parallel for ``` 2. 通过分割任务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值