Linux 进程与线程的区别与联系：定义、资源与调度

返回值：成功返回 0；失败返回错误码（注意错误原因以及错误码都是线程库里面的）。

作用：创建一个线程。

参数：

• **第一个参数：**获取的线程 ID 地址。
• **第二个参数：**设置线程的属性（这个后面再谈，先设置为 NULL）。
• **第三个参数：**线程要执行任务的函数。
  • 函数的返回值是 void *（可以返回任意类型的数据，最后要强制转换）。
  • 函数的参数是 void *（可以给函数传任意类型的数据，传之前要强制转换）。
• **第四个参数：**函数参数。

理解：参数

下面我通过讲解普通函数（无参）、普通函数（一个参数）、传对象来教学如何使用这两个接口：

普通函数（无参）：

假如现在有这样一个线程的任务函数：

void* thread_task(void* arg) {
    std::cout << "Hello pthread" << std::endl;
    // 注意函数是有返回值的
    return NULL;
}

现在如果要利用 pthread_create() 创建线程调用该函数，应该这样使用：

解读：第三个参数由系统调用的函数指针指向任务的函数。 第四个参数为任务函数的参数（指针类型），既然不需要函数参数就传 NULL。

普通函数（有参）：

假如现在有这样一个线程的任务函数，需要传递一个字符串作为参数：

void* thread_task(void* arg) {
    // 注意需要强转回来
    std::cout << (char*)arg << std::endl;
    // 注意函数是有返回值的
    return NULL;
}

解读：该函数的参数需要先强转为 void*，保持与函数原型一致（传参和函数的参数都必须是 void*），随后在使用的时候再强转回来。

结构体参数：

假如有下面这样一个结构体对象：（不管怎样第三个参数只能是函数）

struct Person {
    Person(const char* ptr, int age) :_ptr(ptr),_age(age) {}
    const char*_ptr;
    int _age;
};

void* thread_task(void* arg) {
    // 注意需要强转回来
    std::cout << (((struct Person*)arg)->_ptr) << std::endl;
    std::cout << (((struct Person*)arg)->_age) << std::endl;
    // 注意函数是有返回值的
    return NULL;
}

解读：不管是传什么参数，都要求指针且必须强转为 void 类型*，与函数原型一致，随后使用参数的时候再强转回来。

理解：返回值

返回值的原理都是一样的：先强转为（void*）指针返回，外面需要有一个接收参数的（void）指针，同时需要告诉线程返回值存放的位置*，拿到之后再强转回来使用。

struct Person {
    Person(const char* ptr, int age) :_ptr(ptr),_age(age) {}
    const char*_ptr;
    int _age;
};

void* thread_task(void* arg) {
    // 注意需要强转回来
    struct Person* ptr=(struct Person*)arg;
    // 注意函数是有返回值的
    return (void*)new struct Person(ptr->_ptr,ptr->_age);
}

（3）pthread_join()

原型：

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

参数：

• thread：需要等待的子线程 ID（由 pthread_create 函数返回）。
• retval：用于存储子线程的返回值（即子线程函数 return 的指针）（无返回值就填 NULL）。

返回值：

• 成功：返回 0。
• 失败：返回非零错误码。

作用：阻塞等待子线程结束并获取其返回值（回收资源）。

（4）pthread_exit()

原型：

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

参数：指向线程返回值的指针，用于传递线程的退出状态。

作用：当前线程会立即停止执行，退出并进入'终止状态'，并可通过 pthread_join 获取返回值。

（5）pthread_cancel()

原型：

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

参数：目标线程的 ID。

作用：向目标线程发送取消请求，其核心是'请求'而非'强制终止'。

（6）pthread_self()

原型：

#include <pthread.h>
pthread_t pthread_self(void);

作用：获取当前线程的 ID（标识符）（类似 getpid()）。

补充：我们还可以通过指令 ps -La 获取所有线程 ID（PID 代表进程，LWP 代表线程）。

七、性质验证

我先形成验证需要的代码：给线程开辟堆空间，用容器来存储结构体指针（形成三个线程为例）。

#include<unistd.h>
#include<iostream>
#include<pthread.h>
#include<vector>
#define MAX 3

class My_Pthread {
public:
    My_Pthread(pthread_t id, int name) :_id(id),_name(name) {}
    // 线程 ID
    pthread_t _id=0;
    // 线程名
    int _name;
};

// 线程任务函数
void* handle(void* arg) {
    // 防止线程跑太快
    sleep(1);
    // 强转
    My_Pthread* ptr=(My_Pthread*)arg;
    //std::cout<<"线程编号"<<(ptr->_name)<<"线程 ID："<<(ptr->_id)<<std::endl;
    return NULL;
}

int main() {
    // 用指针来存取线程信息
    std::vector<My_Pthread*> pthread_pointer;
    for(int i=1;i<=MAX;i++) {
        pthread_t id;
        // 线程执行任务
        My_Pthread* ptr=new My_Pthread(id,i);
        // 存储线程数据
        pthread_pointer.push_back(ptr);
        pthread_create(&id,NULL,handle,(void*)ptr);
        ptr->_id=id;
    }
    // 线程等待
    for(int i=0;i<MAX;i++) {
        pthread_join(pthread_pointer[i]->_id,NULL);
    }
    // 回收空间
    for(int i=0;i<MAX;i++) {
        delete pthread_pointer[i];
    }
    return 0;
}

（1）验证：堆空间共享

创建一个全局的堆空间，然后每个线程填入自己的 ID。

结果如下：多个线程可以访问同一块堆内存区域。

（2）验证：栈空间各自开辟

在线程函数内部设置一个变量，修改某一个线程的变量数据，看是否后面线程随着更改。

结果如下：每个线程拥有独立的栈空间，互不影响。

（3）验证：主线程可访问线程数据

在线程函数内部修改数据，外面用主线程访问：线程 3 的_date 数据。

结果如下：主线程可以通过共享内存访问线程数据。

（4）__thread 关键字

__thread 的本质是让变量成为'线程私有'：

全局声明的 __thread 变量，会为每个线程分配独立的内存空间（副本）。 线程内部对该变量的读写，操作的是自己的副本，与其他线程完全隔离。 变量的生命周期与线程一致（线程创建时初始化，线程结束时自动销毁）。

理想效果：每个线程访问数据段中的 date 全局变量时，都是从 9000 开始访问。

测试结果：每个线程拥有独立的变量副本。