<think>我们正在解析pthread_create函数的用途和使用方法。根据提供的引用，我们可以总结如下：
1. **函数原型**：
- 引用[1]和[2]提供了函数原型：
```c
int pthread_create(pthread_t *tid, const pthread_attr_t *tattr, void*(*start_routine)(void *), void *arg);
```
或
```c
int pthread_create(pthread_t* restrict tidp, const pthread_attr_t* restrict_attr, void* (*start_rtn)(void*), void *restrict arg);
```
2. **参数说明**：
- `pthread_t *tid` (或 `tidp`): 用于返回新创建线程的线程ID。
- `const pthread_attr_t *tattr` (或 `restrict_attr`): 线程属性，通常设为NULL表示使用默认属性。
- `void*(*start_routine)(void *)` (或 `start_rtn`): 线程函数的指针，该函数接受一个`void*`参数并返回`void*`。
- `void *arg`: 传递给线程函数的参数。
3. **返回值**：
- 成功时返回0，失败时返回错误码（非零值）。
4. **使用方法**：
- 引用[3]和[4]提供了示例代码，展示了如何传递参数给线程函数：
- 传递单个参数：直接传递变量的地址（注意变量的生命周期）。
- 传递多个参数：需要定义一个结构体，包含所有参数，然后传递结构体的地址。
5. **注意事项**：
- 引用[4]强调了以下几点：
- 注意变量的作用域和生命周期。如果传递局部变量的地址，要确保在线程使用该变量时，该变量仍然有效（例如，主线程不能提前结束）。
- 通常需要调用`pthread_join`来等待线程结束并回收资源，或者使用`pthread_detach`将线程设置为分离状态。
- 如果不调用`pthread_join`，主线程可能先结束，导致新线程没有机会执行完毕。
6. **示例代码**（基于引用[3]和[4]）：
- 传递单个整数：
```c
#include <iostream>
#include <pthread.h>
using namespace std;
void* fn(void *arg) {
int i = *(int *)arg;
cout << "i = " << i << endl;
return NULL;
}
int main() {
pthread_t thread;
int i = 10;
int err = pthread_create(&thread, NULL, fn, &i);
if (err) {
// 错误处理
}
pthread_join(thread, NULL); // 等待线程结束
return 0;
}
```
- 传递多个参数（使用结构体）：
```c
#include <iostream>
#include <pthread.h>
using namespace std;
struct ThreadData {
int a;
char b;
};
void* run(void *arg) {
ThreadData* data = (ThreadData*)arg;
cout << "a = " << data->a << ", b = " << data->b << endl;
return NULL;
}
int main() {
pthread_t thread;
ThreadData data = {10, 'x'};
int err = pthread_create(&thread, NULL, run, &data);
if (err) {
// 错误处理
}
pthread_join(thread, NULL);
return 0;
}
```
7. **重要提醒**：
- 当传递局部变量的地址时，要确保线程在变量超出作用域之前使用它。在上面的例子中，我们通过`pthread_join`保证了主线程等待子线程结束，因此`data`和`i`在子线程使用期间都是有效的。
- 如果线程函数需要长时间运行，而主线程不能等待，则应该将数据动态分配（使用`malloc`或`new`），并在线程函数中释放，或者使用全局变量（但要考虑线程安全）。
根据以上分析，我们可以回答用户的问题。
**回答**：
`pthread_create` 函数是 POSIX 线程（pthread）库中用于创建新线程的函数。下面将详细解析其用途、参数说明及使用方法。
### 用途
`pthread_create` 用于创建一个新的线程，新线程将执行指定的函数（称为线程函数）。该函数使得程序能够实现并发执行，充分利用多核处理器资源[^1][^2]。
### 函数原型
```c
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
```
### 参数说明
1. **`thread`**（输出参数）:
指向 `pthread_t` 类型变量的指针，用于存储新线程的标识符（线程ID）。
2. **`attr`**（输入参数）:
线程属性，通常设置为 `NULL` 表示使用默认属性（如默认栈大小、调度策略等）。如需自定义属性，需先创建并初始化 `pthread_attr_t` 对象[^1][^2]。
3. **`start_routine`**（函数指针）:
线程函数的指针。该函数的签名必须为：
```c
void *function_name(void *arg);
```
线程启动后将执行此函数。
4. **`arg`**（输入参数）:
传递给线程函数的参数。可以是任意类型的指针（`void*`），通常用于传递数据或结构体地址[^3][^4]。
### 返回值
- **成功**: 返回 `0`。
- **失败**: 返回错误码（非零值），如 `EAGAIN`（资源不足）或 `EINVAL`（无效属性）[^1][^2]。
### 使用方法
#### 基本步骤
1. 定义线程函数，其参数和返回值类型必须为 `void*`。
2. 声明 `pthread_t` 变量存储线程ID。
3. 调用 `pthread_create` 创建线程。
4. 使用 `pthread_join` 等待线程结束并回收资源，或使用 `pthread_detach` 分离线程（由系统自动回收）[^4]。
#### 示例代码
##### 示例1：传递整数参数
```c
#include <pthread.h>
#include <stdio.h>
void* print_number(void *arg) {
int num = *(int*)arg; // 将void*转换为int*
printf("Received: %d\n", num);
return NULL;
}
int main() {
pthread_t tid;
int value = 42;
// 创建线程，传递value的地址
int ret = pthread_create(&tid, NULL, print_number, &value);
if (ret != 0) {
perror("Thread creation failed");
return 1;
}
pthread_join(tid, NULL); // 等待线程结束
return 0;
}
```
##### 示例2：传递结构体参数（多参数）
```c
#include <pthread.h>
#include <stdio.h>
typedef struct {
int id;
char name[20];
} Data;
void* print_data(void *arg) {
Data* data = (Data*)arg;
printf("ID: %d, Name: %s\n", data->id, data->name);
return NULL;
}
int main() {
pthread_t tid;
Data d = {1, "Thread 1"};
int ret = pthread_create(&tid, NULL, print_data, &d);
if (ret != 0) {
perror("Thread creation failed");
return 1;
}
pthread_join(tid, NULL);
return 0;
}
```
### 注意事项
1. **参数生命周期**:
若传递局部变量的地址（如示例1中的 `&value`），需确保线程在使用该变量时，其未被销毁。通过 `pthread_join` 可保证主线程等待子线程结束[^4]。
2. **动态分配参数**:
若线程运行时间较长，建议动态分配参数内存（如 `malloc`），并在线程函数中释放：
```c
Data *d = malloc(sizeof(Data));
d->id = 1;
strcpy(d->name, "Dynamic");
pthread_create(&tid, NULL, print_data, d);
// 在线程函数中释放d
```
3. **线程分离**:
若不需等待线程结束，可调用 `pthread_detach(tid)` 使线程分离，结束后自动释放资源[^2][^4]。
4. **错误处理**:
始终检查 `pthread_create` 的返回值，避免资源泄漏或未定义行为。
### 总结
`pthread_create` 是实现多线程编程的核心函数，通过合理设计线程函数和参数传递机制，可实现高效的并发程序。使用时需重点关注参数的生命周期和线程资源管理[^1][^2][^3][^4]。
§§相关问题§§
1. `pthread_create` 函数中线程属性 `attr` 可以设置哪些具体选项？
2. 如何向线程函数传递多个不同类型的参数？
3. `pthread_join` 和 `pthread_detach` 的区别是什么？分别在什么场景下使用？
4. 如果主线程先于子线程退出，会对程序产生什么影响？</think>### pthread_create函数详解
`pthread_create`是POSIX线程库中的核心函数，用于创建新的线程。以下是详细解析：
#### **函数原型**
```c
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)(void *),
void *arg);
```
[^1][^2]
#### **参数说明**
1. **`thread`**（输出参数）
- 类型：`pthread_t*`
- 作用：存储新线程的ID（线程标识符）
- 示例：`pthread_t tid; pthread_create(&tid, ...)`
2. **`attr`**（线程属性）
- 类型：`const pthread_attr_t*`
- 作用：设置线程属性（栈大小、调度策略等）
- 特殊值：`NULL`表示使用默认属性
- 示例：`pthread_create(..., NULL, ...)` [^1][^2]
3. **`start_routine`**（线程函数）
- 类型：`void* (*)(void *)`
- 作用：新线程执行的入口函数
- 要求：必须返回`void*`，参数为`void*`
- 示例：`void* thread_func(void *arg) { ... }` [^3]
4. **`arg`**（线程参数）
- 类型：`void*`
- 作用：传递给线程函数的参数
- 可传递：基本类型、结构体、对象指针等
- 示例：`pthread_create(..., thread_func, &my_data)` [^3][^4]
#### **返回值**
- **成功**：返回 `0`
- **失败**：返回错误码（非零值），如：
- `EAGAIN`：资源不足
- `EINVAL`：无效属性设置
---
### **使用方法与示例**
#### **基础流程**
```c
#include <pthread.h>
#include <stdio.h>
void* thread_task(void *arg) {
int id = *(int*)arg; // 解析参数
printf("Thread %d running\n", id);
return NULL;
}
int main() {
pthread_t tid;
int thread_id = 1;
// 创建线程
int ret = pthread_create(&tid, NULL, thread_task, &thread_id);
if (ret != 0) {
perror("Thread creation failed");
return 1;
}
pthread_join(tid, NULL); // 等待线程结束
return 0;
}
```
#### **关键注意事项**
1. **参数生命周期**
- 若传递局部变量地址，需确保线程使用时变量未销毁（如用`pthread_join`同步）[^4]
- 动态分配参数示例：
```c
int *data = malloc(sizeof(int));
*data = 10;
pthread_create(&tid, NULL, thread_func, data);
// 在线程函数中释放data
```
2. **传递多个参数**
需封装为结构体：
```c
struct ThreadArgs {
int id;
char name[20];
};
void* thread_func(void *arg) {
struct ThreadArgs *args = (struct ThreadArgs*)arg;
printf("ID: %d, Name: %s\n", args->id, args->name);
free(arg); // 释放内存
return NULL;
}
int main() {
struct ThreadArgs *args = malloc(sizeof(struct ThreadArgs));
args->id = 1;
strcpy(args->name, "Worker");
pthread_create(&tid, NULL, thread_func, args);
// ...
}
```
[^3][^4]
3. **线程同步**
- 必须调用`pthread_join`回收资源，或使用`pthread_detach`分离线程
- 未同步时主线程退出会导致子线程终止[^4]
---
### **典型错误场景**
1. **局部变量失效**
```c
void create_thread() {
int local_var = 5;
pthread_create(&tid, NULL, thread_func, &local_var); // 错误！局部变量可能已销毁
}
```
2. **未等待线程**
```c
int main() {
pthread_create(&tid, NULL, thread_func, NULL);
return 0; // 主线程退出，子线程被强制终止
}
```
正确做法：添加`pthread_join(tid, NULL)`[^4]
---
### **总结**
- **核心作用**：创建异步执行的线程
- **关键点**：
- 参数需通过指针传递，注意生命周期管理
- 必须进行线程同步（join/detach）
- 多参数需用结构体封装
- **典型应用**：并发任务处理、高性能计算、实时系统等
本文深入解析了pthread函数的错误处理机制，包括如何通过返回值判断错误状态而非依赖于全局变量errno，以及如何针对特定错误（如EDEADLK）进行处理。此外，还介绍了如何利用strerror函数获取错误描述并打印。
扫一扫
563
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
