深入理解 Linux 线程控制：多线程编程实战技巧

深入理解 Linux 线程控制：多线程编程实战技巧 | 极客日志

while :; do ps -aL | head -1; ps -aL | grep thread ; sleep 1; done

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

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

// 线程函数
void* mythread(void* args) {
    // 创建一个循环，子线程会打印 6 次
    for (int i = 0; i < 6; i++) {
        sleep(1); // 让线程睡眠 1 秒钟，模拟任务的执行
        cout << "Child Thread" << endl; // 打印'Child Thread'，表示子线程在运行
    }
    return nullptr;
}

// 主函数
int main() {
    pthread_t tid; // 定义一个线程 ID 变量
    // 创建子线程，线程的执行函数是 mythread，其他参数为默认值
    pthread_create(&tid, nullptr, mythread, nullptr);
    
    // 主线程执行，循环 6 次
    for (int i = 0; i < 6; i++) {
        cout << "Main Thread" << endl; // 打印'Main Thread'，表示主线程在运行
        sleep(1); // 让主线程睡眠 1 秒钟
    }
    
    // 等待子线程完成执行
    pthread_join(tid, nullptr); // 阻塞等待 tid 线程执行完毕
    return 0; // 程序正常退出
}

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

// 子线程的执行函数
void* mythread(void* args) {
    // 循环 6 次，每次打印一次信息，并且每次暂停 1 秒
    for (int i = 0; i < 6; i++) {
        sleep(1); // 休眠 1 秒钟
        cout << "Child Thread is running ...." << endl; // 输出子线程运行的提示
    }
    // 返回一个值 100，并强制转换为 void* 类型
    return (void*)100;
}

int main() {
    pthread_t tid; // 定义一个线程 ID 变量
    // 创建子线程，传入 mythread 函数作为线程执行的函数，参数为 nullptr
    pthread_create(&tid, nullptr, mythread, nullptr);
    
    // 主线程运行 6 次，每次输出一次信息，并且每次暂停 1 秒
    for (int i = 0; i < 6; i++) {
        cout << "Main Thread is running .." << endl; // 输出主线程运行的提示
        sleep(1); // 休眠 1 秒钟
    }
    
    void* retval; // 声明一个指向 void 的指针，用于接收子线程的返回值
    // 等待子线程结束，并将子线程的返回值存储到 retval 中
    pthread_join(tid, &retval);
    
    // 输出子线程的返回值，将其强制转换为整数类型并输出
    cout << (int64_t)retval << endl; // 输出子线程的返回值，转换为整数
    return 0;
}

#include <pthread.h>
void pthread_exit(void* retval);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

void* mythread(void* args) { // 线程函数
    // 子线程执行的操作，循环输出 "Child Thread is running ...."
    for (int i = 0; i < 6; i++) {
        sleep(1); // 每次休眠 1 秒
        cout << "Child Thread is running ...." << endl;
    }
    // 输出结束前的信息
    cout << "Child Pthread_exit" << endl;
    // 使用 pthread_exit 显式退出线程并返回一个状态码 100
    pthread_exit((void*)100);
    // 这一行代码不会被执行到，因为 pthread_exit 已经退出线程
    return (void*)100;
}

int main() {
    pthread_t tid; // 声明一个线程标识符
    // 创建线程
    pthread_create(&tid, nullptr, mythread, nullptr);
    
    // 主线程执行的操作
    for (int i = 0; i < 6; i++) {
        cout << "Main Thread is running .." << endl;
        sleep(1); // 每次休眠 1 秒
    }
    
    // 主线程休眠，确保子线程有时间执行
    sleep(8); // 等待子线程执行完毕
    
    // 主线程结束前输出信息
    cout << "main return " << endl;
    return 0; // 程序结束
}

#include <pthread.h>
int pthread_cancel(pthread_t thread);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <vector>
#include <string>
using namespace std;

// Hex 函数，用于将整数转换为十六进制字符串
string Hex(int data) {
    char buff[1034] = {0};
    // snprintf 用于将整数 data 转换为十六进制字符串
    snprintf(buff, sizeof(buff), "0x%x", data);
    return buff;
}

// 线程函数，打印每个线程的整数值
void* mythread(void* args) {
    // 将传入的参数指针转换为整型指针
    int* i = (int*)args;
    while (true) { // 无限循环，模拟线程的持续运行
        sleep(1); // 每次休眠 1 秒
        cout << "thread: " << *i << endl; // 输出线程 ID（即传递给线程的值）
    }
    return (void*)100; // 返回一个指针类型的值，通常线程退出时返回状态
}

int main() {
    // 定义一个 vector 来存储线程 ID
    vector<pthread_t> th;
    
    // 创建 4 个线程
    for (int i = 0; i < 4; i++) {
        pthread_t tid; // 定义一个线程 ID 变量
        // 创建线程，将线程 ID、线程函数（mythread）以及传递给线程的参数（i 的地址）传入
        pthread_create(&tid, nullptr, mythread, &i);
        // 将线程 ID 添加到线程容器中
        th.push_back(tid);
    }
    
    cout << "ready cancel" << endl;
    sleep(3); // 休眠 3 秒，等待线程输出
    
    // 取消每个创建的线程
    for (int i = 0; i < th.size(); i++) {
        cout << "cancel: thread " << i << endl; // 输出正在取消的线程编号
        pthread_cancel(th[i]); // 取消对应的线程
    }
    
    sleep(1); // 稍等 1 秒，确保线程能够响应取消请求
    cout << "main return " << endl; // 输出主线程返回信息
    return 0; // 程序结束
}

#include <pthread.h>
int pthread_detach(pthread_t thread);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <vector>
#include <string>
using namespace std;

// Hex 函数：将整数转换为十六进制字符串
string Hex(int data) {
    char buff[1034] = {0};
    snprintf(buff, sizeof(buff), "0x%x", data); // 将整数以十六进制格式转换成字符串
    return buff;
}

// 线程函数
void* mythread(void* args) {
    pthread_detach(pthread_self()); // 将当前线程设置为分离状态
    int* i = (int*)args; // 将传入的参数指针转换为整型指针
    int n = 3; // 循环打印线程编号（传递给线程的值），共打印 3 次
    while (n--) {
        sleep(1); // 每次循环休眠 1 秒
        cout << "thread: " << *i << endl; // 输出线程的编号
    }
    return (void*)100; // 线程返回值
}

int main() {
    vector<pthread_t> th; // 用于存储线程 ID 的容器
    cout << "线程的创建" << endl;
    
    // 创建 4 个线程
    for (int i = 0; i < 4; i++) {
        pthread_t tid;
        pthread_create(&tid, nullptr, mythread, &i); // 创建线程并传递 i 的地址作为参数
        th.push_back(tid); // 将创建的线程 ID 加入到线程容器中
    }
    
    sleep(10); // 主线程休眠 10 秒，确保所有子线程能运行完
    cout << "main return " << endl;
    return 0; // 主程序结束
}

深入理解 Linux 线程控制：多线程编程实战技巧

前言

监控线程的 Bash 命令

线程的控制

线程的创建 (`pthread_create`)

参数解析：

示例：

线程退出

`pthread_join`

参数说明：

功能描述：

示例：

程序流程：

`pthread_exit`

参数说明：

示例：

程序流程：

`pthread_cancel`

参数说明：

功能描述：

返回值：

示例：

程序流程：

线程分离

参数：

功能描述

示例：

程序执行流程：

更多推荐文章

相关免费在线工具

深入理解 Linux 线程控制：多线程编程实战技巧

前言

监控线程的 Bash 命令

线程的控制

线程的创建 (pthread_create)

参数解析：

示例：

线程退出

pthread_join

参数说明：

功能描述：

示例：

程序流程：

pthread_exit

参数说明：

示例：

程序流程：

pthread_cancel

参数说明：

功能描述：

返回值：

示例：

程序流程：

线程分离

参数：

功能描述

示例：

程序执行流程：

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

线程的创建 (`pthread_create`)

`pthread_join`

`pthread_exit`

`pthread_cancel`