Linux多线程编程实战:从pthread_create到pthread_join的完整指南

Linux线程全面解析:pthread_create、pthread_join等函数详解与应用 线程安全指多线程环境下数据访问的一致性保证方法:互斥锁、原子操作、线程局部存储、不可变对象。 阅读详情

Linux多线程编程实战:从pthread_create到pthread_join的完整指南

在构建高性能服务器、数据处理管道或任何需要并发处理任务的应用程序时,Linux下的多线程编程是开发者绕不开的核心技能。很多朋友初次接触pthread库时,往往会被pthread_create、pthread_join、pthread_exit这一系列函数搞得晕头转向。更棘手的是,线程创建后如何优雅地管理其生命周期,避免资源泄漏和僵尸线程,这些实战中的“坑”远比理解概念本身要复杂。本文将从一线开发者的视角出发,抛开教科书式的理论罗列,聚焦于如何在实际项目中正确、高效地使用POSIX线程。我们会从最基础的线程创建讲起,逐步深入到资源回收、同步控制等高级话题,并通过大量可直接运行的代码示例,手把手带你构建一个健壮的多线程应用骨架。无论你是正在为项目性能优化寻找并发方案,还是希望夯实系统编程基础,这篇文章都将为你提供一套清晰、可落地的实践路径。

1. 线程的基石:理解共享与隔离

在动手写第一行多线程代码之前,我们必须对线程在进程中的“生存状态”有一个清晰的图景。很多人把线程简单理解为“轻量级进程”,这没错,但关键在于理解“轻”在何处,以及由此带来的便利与风险。

一个进程就像一个独立的王国,拥有完整的地址空间、文件描述符表、信号处理方式等资源。线程则是这个王国里的多个执行流,它们共享王国的大部分“公共财产”,但各自拥有独立的“私人工作栈”。这种设计带来了巨大的效率优势:线程间通信成本极低,无需像进程间通信(IPC)那样进行复杂的数据拷贝或系统调用;创建和销毁线程的代价也远小于进程。

线程共享的资源包括:

  • 内存空间:代码段(.text)、已初始化数据段(.data)、未初始化数据段(.bss)以及堆(heap)内存。这意味着,在一个线程中malloc分配的内存,指针可以直接传递给另一个线程读写。
  • 文件描述符:打开的文件、套接字等在进程内是共享的。一个线程accept到的连接,另一个线程可以对其进行读写。
  • 进程ID(PID)和用户/组ID:所有线程同属一个进程。
  • 信号处理函数:为某个信号设置的处理器,对所有线程生效。

线程独有的资源则确保了其执行的独立性:

  • 线程ID(TID):在进程内唯一标识一个线程。
  • 栈空间:每个线程有自己的用户栈,用于存放局部变量、函数调用链等信息。这是线程数据隔离的核心。
  • 程序计数器(PC)和寄存器集:决定了线程执行到了哪里。
  • 错误变量errno:C库的errno是线程安全的,每个线程有自己独立的副本,避免了多线程下错误状态的相互覆盖。
  • 信号屏蔽字:每个线程可以独立设置阻塞哪些信号。

理解这份“财产清单”至关重要。例如,将局部变量的地址传递给另一个线程是极其危险的,因为一旦函数返回,该栈帧可能被回收,访问将导致未定义行为。相反,全局变量或堆内存则是安全的共享媒介。

注意:虽然线程共享堆内存,但对其的并发访问必须通过互斥锁(mutex)、读写锁等同步机制进行保护,否则会导致数据竞争(Data Race),这是多线程编程中最常见的错误之一。

2. 线程的诞生与消亡:pthread_create与pthread_exit

让我们从最核心的创建函数开始。pthread_create的签名看似复杂,但拆解后非常直观。

#include <pthread.h>
int pthread_create(pthread_t *thread,
                   const pthread_attr_t *attr,
                   void *(*start_routine) (void *),
                   void *arg);

一个典型的创建示例如下:

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

void *print_hello(void *thread_id) {
    long tid = (long)thread_id;
    printf("Hello from thread #%ld! My TID is %lu.\n", tid, pthread_self());
    // 线程工作完成后,可以返回值
    void *result = (void *)(tid * 100);
    return result; // 等同于 pthread_exit(result);
}

int main() {
    pthread_t threads[3];
    int rc;
    long t;

    for(t = 0; t < 3; t++) {
        printf("Main: creating thread %ld\n", t);
        rc = pthread_create(&threads[t], NULL, print_hello, (void *)t);
        if (rc) {
            fprintf(stderr, "Error: unable to create thread, %d\n", rc);
            return -1;
        }
    }

    // 主线程不能立即退出,否则可能来不及执行子线程
    // 一种方法是 sleep,但更好的方法是使用 pthread_join(见下一节)
    sleep(1);
    printf("Main thread exiting.\n");
    // 主线程退出,但子线程可能还在运行,这不是好做法
    return 0;
}

编译时需要链接pthread库:

gcc -o thread_demo thread_demo.c -lpthread

关键点解析:

  1. 线程函数:start_routine必须接受一个void*参数并返回void*。这是为了传递任意类型的单一参数和返回值,通常需要强制类型转换。
  2. 参数传递:我们将整数t强制转换为void*传入。在32/64位系统上,直接传递小整数通常是安全的,但更通用的做法是传递堆上分配的结构体地址。
  3. 主线程的职责:上面代码用sleep(1)等待子线程,这非常粗糙且不可靠。如果子线程运行超过1秒,它将被强行终止。正确的做法是让主线程等待子线程结束,这就是pthread_join的用武之地。

线程的退出:线程结束有三种方式:

  1. 从线程函数中return。
  2. 调用pthread_exit(void *retval)。
  3. 被同一进程中的其他线程pthread_cancel取消。

对于主线程(即main函数所在的线程),需要特别注意:如果主线程简单地return 0或调用exit(0),整个进程会立即终止,所有子线程也会被强行杀死,无论它们是否完成了工作。这通常会导致资源泄漏(如未关闭的文件、未释放的锁)。因此,主线程在创建了需要完成工作的子线程后,应该调用pthread_exit(NULL)。pthread_exit只会终止调用它的线程,而进程会持续到所有线程都终止。

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker_thread, NULL);
    // ... 其他工作
    pthread_exit(NULL); // 主线程结束,但进程会等待 worker_thread
    // return 0; // 错误!这会导致进程结束,杀死worker_thread。
}

3. 线程的资源回收:深入理解pthread_join

创建线程只是开始,确保线程资源被正确回收是避免“线程泄漏”(类似僵尸进程)的关键。pthread_join函数扮演了“线程收尸人”的角色。

int pthread_join(pthread_t thread, void **retval);

这个函数会阻塞调用它的线程,直到指定的thread线程终止。然后,它可以获取该线程的退出状态(即线程函数return或pthread_exit传递的值)。

让我们看一个结合了创建、执行和回收的完整例子:

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

// 定义一个结构体来传递复杂参数
struct thread_data {
    int  thread_id;
    char *message;
};

void *worker(void *arg) {
    struct thread_data *my_data = (struct thread_data *)arg;
    printf("Thread %d: %s\n", my_data->thread_id, my_data->message);

    // 模拟一些工作
    int *result = malloc(sizeof(int));
    *result = my_data->thread_id * 10;
    // 退出并返回结果
    pthread_exit((void *)result);
}

int main() {
    pthread_t threads[2];
    struct thread_data td[2];
    void *thread_return[2];

    td[0].thread_id = 1;
    td[0].message = "Processing task A";
    td[1].thread_id = 2;
    td[1].message = "Processing task B";

    for(int i = 0; i < 2; i++) {
        int rc = pthread_create(&threads[i], NULL, worker, (void *)&td[i]);
        if (rc) {
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }

    // 主线程等待所有工作线程完成,并收集结果
    for(int i = 0; i < 2; i++) {
        pthread_join(threads[i], &thread_return[i]);
        if (thread_return[i] != NULL) {
            printf("Main: Thread %d returned %d\n", i+1, *(int *)thread_return[i]);
            free(thread_return[i]); // 释放线程返回的堆内存
        }
    }

    printf("Main: All threads completed successfully.\n");
    pthread_exit(NULL);
}

pthread_join的核心价值与陷阱:

  1. 同步点:pthread_join是一个强大的同步原语。它确保了主线程(或任何其他线程)可以等待一个特定任务完成后再继续。这在生产者-消费者模型或任务分发的场景中非常有用。
  2. 资源清理:线程终止后,其栈空间等系统资源会被释放,但线程的退出状态(一个void*指针)会一直被系统保留,直到有线程对其调用pthread_join。如果永远不join,这部分内核资源就会泄漏。
  3. 返回值所有权:线程返回的指针(上例中的result)指向的内存必须在线程结束后依然有效。因此,绝对不能返回指向线程栈上局部变量的指针。上例中我们在堆上分配(malloc)了结果,并在主线程中free,这是标准做法。也可以返回指向全局静态数据或传入参数的指针。
  4. retval参数:如果对线程的返回值不感兴趣,可以传入NULL。如果线程被pthread_cancel取消,retval会被设置为宏PTHREAD_CANCELED。

必须join吗? 不一定。如果你不关心线程的退出状态,也不想阻塞等待它,可以使用pthread_detach。

4. 分离线程:pthread_detach的适用场景

对于“发射后不管”的后台任务线程(如日志写入、心跳包发送),我们既不关心其结果,也不希望主线程阻塞等待它。这时,可以将其设置为分离状态(detached state)。

一个分离状态的线程在终止时,其资源会自动由系统回收,无需其他线程join。试图join一个已分离的线程会失败(通常返回EINVAL错误)。

设置分离有两种方式:

方式一:创建后分离

pthread_t tid;
pthread_create(&tid, NULL, background_task, NULL);
pthread_detach(tid); // 立即分离
// 此后不能再调用 pthread_join(tid, ...)

方式二:创建时即具分离属性(更推荐) 这种方式避免了pthread_create和pthread_detach之间的微小时间窗口内线程可能已经结束的风险。

#include <pthread.h>
void* daemon_thread(void* arg) {
    // 守护线程的工作
    return NULL;
}

int main() {
    pthread_attr_t attr;
    pthread_t tid;

    // 初始化线程属性对象
    pthread_attr_init(&attr);
    // 设置分离状态属性
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    // 用属性创建线程
    pthread_create(&tid, &attr, daemon_thread, NULL);

    // 销毁属性对象,它不再被需要
    pthread_attr_destroy(&attr);

    // 主线程可以继续做其他事,无需join
    // ...
    pthread_exit(NULL);
}

分离线程的典型应用场景:

  • 网络服务器的连接处理:每个新连接由一个分离线程处理,主线程只需继续accept。
  • 定时或周期性的后台任务。
  • 任何其结果对创建者无关紧要的任务。

提示:一旦线程被分离,就无法再恢复到可连接(joinable)状态。分离线程也不能被其他线程pthread_cancel取消,因为取消了也没人能回收它。通常分离线程会自己管理生命周期,运行到自然结束。

5. 线程的强制终止:谨慎使用pthread_cancel

理论上,你可以用pthread_cancel来请求取消另一个线程。但这是一种非常粗暴的协作机制,在实际项目中应极其谨慎地使用,甚至避免使用。

int pthread_cancel(pthread_t thread);

线程收到取消请求后,并不会立即停止。它的行为取决于其取消状态和取消类型,这两个属性可以通过pthread_setcancelstate和pthread_setcanceltype设置。

  • 取消点:线程只会在特定的函数调用处检查取消请求,这些点称为取消点。包括read, write, sleep, pthread_join, pthread_cond_wait等可能阻塞的系统调用或库函数。如果线程在执行一个不包含取消点的密集计算循环,取消请求会一直被挂起。
  • 异步取消:可以设置取消类型为PTHREAD_CANCEL_ASYNCHRONOUS,这使得取消可以在任何时间点发生,但这极易导致资源泄漏(如锁未释放、文件未关闭),因为程序状态可能处于不一致的中间点。

一个相对安全的使用模式是,让目标线程周期性地检查一个“退出标志”,然后自己优雅地退出。

// 更安全的线程终止方式:使用标志位
volatile int should_exit = 0; // 使用volatile防止编译器优化

void *worker(void *arg) {
    while(!should_exit) {
        // 执行工作单元
        do_work_unit();
        // 在循环中检查退出标志,而非依赖取消点
    }
    printf("Thread exiting cleanly.\n");
    pthread_exit(NULL);
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);

    sleep(5); // 让线程工作一段时间
    should_exit = 1; // 请求退出

    pthread_join(tid, NULL); // 等待线程清理退出
    return 0;
}

为什么pthread_cancel是危险的? 考虑线程可能正持有互斥锁、打开了文件、分配了堆内存。如果它在非预期的时间点被取消,这些资源将永远无法被释放,导致死锁、内存泄漏和文件描述符泄漏。因此,在设计和代码评审中,应明确禁止或严格限制pthread_cancel的使用。

6. 实战:构建一个简单的线程池框架

理解了单个线程的管理后,我们来看一个更贴近实战的场景:线程池。线程池通过预先创建一组线程并重复使用它们来执行任务,避免了频繁创建和销毁线程的巨大开销。下面是一个高度简化的线程池核心框架,展示了如何整合pthread_create, pthread_join以及线程间通信。

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

#define THREAD_NUM 4
#define QUEUE_SIZE 100

// 任务结构体
typedef struct {
    void (*function)(void *);
    void *argument;
} task_t;

// 简单的线程池结构
typedef struct {
    pthread_t threads[THREAD_NUM];
    task_t task_queue[QUEUE_SIZE];
    int queue_head;
    int queue_tail;
    int queue_count;
    pthread_mutex_t queue_lock;
    pthread_cond_t queue_not_empty;
    pthread_cond_t queue_not_full;
    int shutdown;
} thread_pool_t;

// 工作线程函数
void *worker_thread(void *pool_arg) {
    thread_pool_t *pool = (thread_pool_t *)pool_arg;
    task_t task;

    while(1) {
        pthread_mutex_lock(&pool->queue_lock);

        // 等待队列中有任务或线程池关闭
        while(pool->queue_count == 0 && !pool->shutdown) {
            pthread_cond_wait(&pool->queue_not_empty, &pool->queue_lock);
        }

        if(pool->shutdown && pool->queue_count == 0) {
            pthread_mutex_unlock(&pool->queue_lock);
            pthread_exit(NULL);
        }

        // 取任务
        task = pool->task_queue[pool->queue_head];
        pool->queue_head = (pool->queue_head + 1) % QUEUE_SIZE;
        pool->queue_count--;

        pthread_cond_signal(&pool->queue_not_full);
        pthread_mutex_unlock(&pool->queue_lock);

        // 执行任务
        (*(task.function))(task.argument);
        // 注意:这里需要根据argument的实际类型决定是否释放内存
    }
    return NULL;
}

// 初始化线程池
int thread_pool_init(thread_pool_t *pool) {
    pool->queue_head = 0;
    pool->queue_tail = 0;
    pool->queue_count = 0;
    pool->shutdown = 0;

    pthread_mutex_init(&pool->queue_lock, NULL);
    pthread_cond_init(&pool->queue_not_empty, NULL);
    pthread_cond_init(&pool->queue_not_full, NULL);

    for(int i = 0; i < THREAD_NUM; i++) {
        if(pthread_create(&pool->threads[i], NULL, worker_thread, pool) != 0) {
            // 创建失败,需要清理已创建的线程(略)
            return -1;
        }
    }
    return 0;
}

// 向线程池提交任务(简化版,未处理队列满的情况)
int thread_pool_submit(thread_pool_t *pool, void (*func)(void *), void *arg) {
    pthread_mutex_lock(&pool->queue_lock);

    // 这里应该检查队列是否已满,为了示例简洁省略
    pool->task_queue[pool->queue_tail].function = func;
    pool->task_queue[pool->queue_tail].argument = arg;
    pool->queue_tail = (pool->queue_tail + 1) % QUEUE_SIZE;
    pool->queue_count++;

    pthread_cond_signal(&pool->queue_not_empty);
    pthread_mutex_unlock(&pool->queue_lock);
    return 0;
}

// 销毁线程池
void thread_pool_destroy(thread_pool_t *pool) {
    pthread_mutex_lock(&pool->queue_lock);
    pool->shutdown = 1;
    pthread_mutex_unlock(&pool->queue_lock);

    // 唤醒所有等待的工作线程,让它们退出
    pthread_cond_broadcast(&pool->queue_not_empty);

    // 等待所有工作线程结束
    for(int i = 0; i < THREAD_NUM; i++) {
        pthread_join(pool->threads[i], NULL);
    }

    pthread_mutex_destroy(&pool->queue_lock);
    pthread_cond_destroy(&pool->queue_not_empty);
    pthread_cond_destroy(&pool->queue_not_full);
}

// 示例任务函数
void print_task(void *arg) {
    int *num = (int *)arg;
    printf("Task processing: %d (Thread ID: %lu)\n", *num, pthread_self());
    sleep(1); // 模拟耗时操作
}

int main() {
    thread_pool_t pool;
    thread_pool_init(&pool);

    // 提交一些任务
    for(int i = 0; i < 10; i++) {
        int *arg = malloc(sizeof(int)); // 任务参数需要动态分配
        *arg = i;
        thread_pool_submit(&pool, print_task, arg);
        // 注意:任务函数或销毁函数需要负责释放arg内存,本例中省略了
    }

    sleep(5); // 等待任务执行一段时间
    printf("Shutting down thread pool...\n");
    thread_pool_destroy(&pool);
    printf("All done.\n");
    return 0;
}

这个框架虽然简化,但清晰地展示了多线程编程的几个核心要素:

  1. 线程创建与回收:thread_pool_init中创建所有工作线程,thread_pool_destroy中pthread_join所有线程。
  2. 线程同步:使用互斥锁(pthread_mutex_t)保护共享的任务队列,使用条件变量(pthread_cond_t)进行线程间通信(通知队列非空/非满)。
  3. 线程生命周期管理:通过shutdown标志优雅地通知所有工作线程退出,避免了强制取消。
  4. 资源管理:任务参数的内存分配与释放(示例中未完全展示,实际需要仔细设计)。

在实际项目中,你还需要处理队列满时的阻塞提交、更灵活的任务参数生命周期管理、线程池的动态大小调整等复杂问题。但万变不离其宗,其基础正是对pthread API的扎实理解和正确运用。

系统编程05-线程(pthread_create、pthread_join、pthread_exit) 阅读详情

相关推荐

windows11 远程桌面连接 通过代理连接RDP桌面报错 错误代码0x904 拓展错误代码0x7

打开windows Defender防火墙设置--允许应用通过防火墙更改设置--允许其他应用浏览--进入C:\WINDOWS\system32目录选择mstsc.exe进入C:\Windows\SysWOW64目录h'qmstsc.exe添加后列表里多了一个远程桌面连接,还有一个Remote Desktop Connection,配置网络权限后保存连接成功。

weixin_43978891的博客 1万+

Java中布尔类型

在Java中,布尔类型使用。

机器小番茄 1327

山景BP10_128DBG开发板通过蓝牙连接手机放歌实验回顾

最近在学习上海山景公司的BP10_128DBG的开发板,因为网上关于BP10开发板的帖子也比较少,在学习的时候也没有太多的参考资料,基本上都是官方的历程。蓝牙放歌这个demo对我来说也比较复杂,特写下此博客进行记录、总结,大家有需要的可以参考。

weixin_56646002的博客 2023

1106. 解析布尔表达式

给你一个以字符串形式表述的 布尔表达式(boolean) expression,返回该式的运算结果。 有效的表达式需遵循以下约定: “t”,运算结果为 True “f”,运算结果为 False “!(expr)”,运算过程为对内部表达式 expr 进行逻辑 非的运算(NOT) “&(expr1,expr2,…)”,运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 与的运算(AND) “|(expr1,expr2,…)”,运算过程为对 2 个或以上内部表达式 expr1,

qq_45638271的博客 996

Go语言AI智能体开发实战:基于LangGraphGo构建下一代工作流引擎

在AI应用开发领域,工作流编排是构建复杂智能系统的核心技术。其核心原理是将任务执行过程建模为状态图,通过节点和边的组合定义数据流转路径,实现多步骤推理与工具调用的自动化。这种基于状态图的编程模型,为智能体提供了清晰的“思考-行动-观察”循环抽象,显著提升了复杂业务逻辑的可维护性和可观测性。从技术价值看,它解决了传统代码中状态分散、流程僵化的问题,支持条件分支、并行执行等高级模式,是实现生产级AI应用的关键基础设施。在应用场景上,该技术广泛适用于客服机器人、自动化审批、数据ETL等需要多步骤协调的领域。本文以

weixin_30457551的博客 365

【Unity】入门教程第一期-下载安装Unity编辑器(下)

讲解如何在Unity Hub中下载Unity编辑器以及IED环境

Xiaoxin的博客 2042

JAVA布尔运算

对于布尔类型boolean,永远只有true和false两个值。 布尔运算是一种关系运算,包括以下几类: 比较运算符:>,>=,<,<=,==,!= 与运算 && 或运算 || 非运算 ! 下面是一些示例: boolean isGreater = 51 > 32; // true int age = 12; boolean is...

u012289399的博客 994

告别密码明文传输:手把手带你用Python实现SRP-6协议(附完整代码)

本文详细介绍了如何使用Python实现SRP-6协议,确保密码安全传输和存储。通过零知识证明与密钥交换技术,SRP协议在不传输明文密码的情况下完成认证,适用于金融App等高安全需求场景。文章包含完整代码示例和实战技巧,帮助开发者规避常见安全陷阱。

weixin_30689307的博客 414

java 布尔表达式,Java中的布尔表达式优化

Consider the following method in Java:public static boolean expensiveComputation() {for (int i = 0; i < Integer.MAX_VALUE; ++i);return false;}And the following main method:public static void main(S...

weixin_39995943的博客 319

别再乱用标签了!深度解析Unity Addressables标签(Labels)的三种高级用法与性能影响

本文深度解析Unity Addressables标签(Labels)的三种高级用法与性能影响,包括标签组合查询、Pack Together by Label打包策略及运行时性能优化。通过实战代码示例和性能数据对比,帮助开发者实现精细化资源加载控制与包体优化,提升项目效率。

weixin_30500105的博客 509

分享一个完整的KANO问卷(包含正反问题和选项设置)

本文介绍了KANO模型问卷的设计与应用,用于评估功能需求优先级。问卷包含基本信息、功能评估(正反问题设计)、界面评估及开放问题,选项定义明确(如"非常喜欢"到"很不喜欢")。数据清洗规则包括剔除矛盾回答和注意力检验。通过量化编码和矩阵分析,将需求分为魅力型、期望型、必备型等类别。示例数据显示健康监测为必备型(72%),电子围栏为期望型(45%),适老化改造为无差异型(38%)。该模型为产品决策提供客观量化依据。

从技术实践立足,从项目管理方法论延伸思考 1797

JAVA程序设计:解析布尔表达式(LeetCode:1106)

给你一个以字符串形式表述的布尔表达式(boolean) expression,返回该式的运算结果。 有效的表达式需遵循以下约定: "t",运算结果为 True "f",运算结果为 False "!(expr)",运算过程为对内部表达式 expr 进行逻辑 非的运算(NOT) "&(expr1,expr2,...)",运算过程为对 2 个或以上内部表达式 expr1, expr2, ... 进行逻辑 与的运算(AND) "|(expr1,expr2,...)",运算过程为对 2 个或以上内部表达.

信仰.的博客 3679

PSO-BP和BP多输入多输出回归预测模型 matlab (多输入多输出)

PSO-BP和BP多输入多输出回归预测模型 matlab (多输入多输出)

算法如诗的博客 258

多线程之pthread_create()函数

总述:pthread_create是(Unix、Linux、Mac OS X)等操作系统的创建线程的函数。它的功能是创建线程(实际上就是确定调用该线程函数的入口点),在线程创建以后,就开始运行相关的线程函数。 pthread_create的返回值表示成功,返回0;表示出错,返回表示-1。 pthread_create函数如何创造线程 函数原型声明: #include &lt;pth...

wushuomin的博客 16万+

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

与线程有关的几个函数pthread_create、pthread_detach、pthread_join、pthread_mutex_lock、pthread_cond_wait等用法

     线程,有时被称为轻量进程,在我们平常开发中经常会用到,关于线程的介绍网上有很多,在这里我就不再做介绍了。我主要介绍下载Linux我们经常用到的几个与线程有关的函数。 pthread_create     创建线程函数,函数声明为         int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *res...

haofeng_ma的博客 5274

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

pthread_join的使用-

from:https://blog.youkuaiyun.com/u012989012/article/details/80800168 join 在Linux中,新建的线程并不是在原先的进程中,而是系统通过一个系统调用clone()。该系统调用clone() copy了一个和原先进程完全一样的进程,并在这个进程中执行线程函数。不过这个copy过程和fork不一样。 copy后的进程和原先的进程共享了...

frank的专栏 4万+

多线程之pthread_create()

总述:pthread_create是(Unix、Linux、Mac OS X)等操作系统的创建线程的函数。它的功能是创建线程(实际上就是确定调用该线程函数的入口点),在线程创建以后,就开始运行相关的线程函数。 pthread_create的返回值表示成功,返回0;表示出错,返回表示-1。 pthread_create函数如何创造线程函数原型声明: #include <pthread.h> int pthread_create( pthread_t *res

CodeAllen嵌入式 3万+

【linux】多线程(二)线程控制pthread_create,pthread_join,pthread_exit,pthread_cancel,pthread_self

一、pthread线程库 二、线程创建pthread_create 三、线程等待pthread_join 四、零碎知识 全局变量 可重入函数 五、线程终止pthread_exit,pthread_cancel 获取线程的tid,pthread_self 六、线程函数传递对象 c++11中的多线程 七、线程的管理 八、如何理解pthread_join中的参数是二级指针retval 九、如何理解线程的独立栈

重铸自身根基的博客 1405

【c语言多线程编程】关于pthread_create()和pthread_join()的多线程详解

pthread_join() 函数会一直阻塞调用它的线程,直至目标线程执行结束(接收到目标线程的返回值),阻塞状态才会解除。再次强调,一个线程执行结束的返回值只能由一个 pthread_join() 函数获取,当有多个线程调用 pthread_join() 函数获取同一个线程的执行结果时,哪个线程最先执行 pthread_join() 函数,执行结果就由那个线程获得,其它线程的 pthread_join() 函数都将执行失败。对于一个默认属性的线程 A 来说,线程占用的资源并不会因为执行结束而得到释放。

笑着的程序员的博客 2183

Linux C pthread多线程,join和detach

Linux C多线程使用,有一个注意点需要注意,新启动的子线程一定要在主线程join,或者本身被设置为detach,否则会引起资源泄露,如每个线程都有自己的运行stack,内核中的task_stuct数据结够等。正如,父子进程中的子进程退出没有被父进程join就会变成僵尸进程一样。 一个例子,最终会导致资源耗尽 pthread_create 返回 11. 这个错误是 EAGAIN 的意思就是操作系...

Life runs on code 1418

Linux下c语言多线程编程

引言   线程(thread)技术早在60年代就被提出,但真正应用多线程到操作系统中去,是在80年代中期,solaris是这方面的佼佼者。传统的Unix也支持线程的概念,但是在一个进程(process)中只允许有一个线程,这样多线程就意味着多进程。现在,多   为什么有了进程的概念后,还要再引入线程呢?使用多线程到底有哪些好处?什么的系统应该选用多线程?我们首先必须回答这些问题。   使用...

木牛的博客 7579

多线程之pthread_create()、pthread_join() 和 pthread_detach()函数

多线程之pthread_create()、pthread_join() 和 pthread_detach()函数头文件pthread_create合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 头文件 #include<pthread

maodewubu的博客 965

Linux复习:pthread的create和join,detach

本文demo运行在阿里云的服务器,Centos系统 首先复习进程和线程的资源关系。 进程内典型全局资源如下: 1)代码区:这意味着当前进程空间内所有的可见的函数代码,对于每个线程来说,也是可见的 2)静态存储区:全局变量,静态空间 3)动态存储区:堆空间 线程内典型的局部资源: 1)本地栈空间:存放本线程的函数调用栈,函数内部的局部变量等 2)部分寄存器变量:线程下一步要执行代码...

编程爱好者的博客 1250

【linux系统编程学习笔记】第八节:线程初认识(pthread_create 线程创建、pthread_join  线程回收、pthread_exit  线程退出)

线程初认识 线程的基本概念 线程特点及API pthread_create 线程创建 pthread_join 线程回收 pthread_exit 线程退出 例程: 线程的基本概念 线程实际上是应用层的概念,一个进程内部的多条线程共享了大部分资源,但是还是有一些信息是各自独立的一一比如其运行状态,当一个线程处于睡眠的时候,另一条线程可以正在运行,而或许有些线程已经变成僵尸了!就像一个人是如果是多线程的,他就可以做到一边睡觉一边吃饭一边在洗澡!正是利用线程状态独立的特征,程...

qq_44796935的博客 1945

linux_线程基础函数-pthread_self函数-pthread_create函数-pthread_exit函数-pthread_join函数

在一个线程中调用pthread_create()创建新的线程后,当前线程从pthread_create()返回继续往下执行,而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。线程id的类型是thread_t,它只在当前进程中保证是唯一的,在不同的系统中thread_t这个类型有不同的实现,它可能是一个整数值,也可能是一个结构体,也可能是一个地址,所以不能简单地当成整数用printf打印,调用pthread_self(3)可以获得当前线程的id。

qq_44177918的博客 4170
上一篇: Python+OP模块实战:雷电模拟器上实现阴阳师后台挂机(附完整代码)
下一篇: SpringBoot整合Stripe支付实战:从沙盒测试到Webhook回调的完整避坑指南
Python
博客等级 码龄26年 1973粉丝 1567原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值