Linux----线程

张裕 · 2025-2-25 00:28:41

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

一、基础概念对比

特性进程 (Process)线程 (Thread)资源分配资源分配的根本单位（独立所在空间）共享进程资源调度单位操作体系调度单位CPU调度的最小单位创建开销高（需复制父进程资源）低（共享进程资源）通讯方式管道、共享内存、消息队列等IPC共享全局变量（需同步机制）隔离性内存隔离，安全性高共享内存，需处理竞争条件典范组成代码段+数据段+堆栈段+PCB线程ID+寄存器组+栈+线程控制块TCB

二、线程组成详解

1. 核心组件

struct thread_struct {
pthread_t tid; // 线程ID (8字节)
void* stack_base; // 栈基地址 (8字节)
size_t stack_size; // 栈大小 (Linux默认8MB)
void* (*start_routine)(void*); // 入口函数指针
void* arg; // 入口函数参数
// 寄存器组保存区 (约52个寄存器，约416字节)
// 包括：PC、SP、通用寄存器、浮点寄存器等
};

复制代码

2. 关键特征

线程ID：pthread_t 范例，进程内唯一
独立栈空间：每个线程拥有独立调用栈
共享资源：全局变量、堆内存、文件形貌符等

三、线程创建与管理

1. 创建函数原型

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

复制代码

参数详解表

参数范例作用说明threadpthread_t*输出参数，存储新线程IDattrpthread_attr_t*线程属性（NULL利用默认属性）：<br>▪ 栈巨细<br>▪ 调度策略<br>▪ 分离状态start_routinevoid* (*)(void*)线程入口函数（返回值为线程退出状态）argvoid*传递给入口函数的参数返回值

成功返回0
失败返回错误码（非errno值，需用strerror转换）

2. 编译指令

gcc program.c -lpthread -o program # 必须链接pthread库

复制代码

四、线程生命周期管理

1. 线程终止方式

(1) 显式调用退出函数

void* worker(void* arg) {
int* heap_result = malloc(sizeof(int));
*heap_result = 100;
pthread_exit((void*)heap_result); // 正确方式：堆内存传递
// static int static_result = 200; // 替代方案：静态变量
// pthread_exit((void*)&static_result);
}

复制代码

关键特性：

状态值通过pthread_join()获取
返回值必须利用堆内存或全局/静态变量
主线程调用时仅竣事自身实行流

(2) 入口函数返回

void* worker(void* arg) {
static int result = 200; // 必须使用静态存储期变量
return (void*)&result; // 等效于pthread_exit()
}

复制代码

禁止举动：

int local_var = 300;
return (void*)&local_var; // 错误！栈空间失效

复制代码

(3) 被其他线程取消

// 取消请求端
pthread_cancel(target_tid);
// 被取消线程端
void* worker(void* arg) {
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
while(1) {
pthread_testcancel(); // 设置取消点
/* 长时间操作 */
}
}

复制代码

取消范例对比：
范例举动特征设置函数PTHREAD_CANCEL_DEFERRED耽误到下一个取消点pthread_setcanceltype()PTHREAD_CANCEL_ASYNCHRONOUS立即终止（可能破坏数据）pthread_setcanceltype() (4) 进程级终止

int main() {
pthread_t tid;
pthread_create(&tid, NULL, worker, NULL);
// return 0; // 错误！触发exit()终止所有线程
pthread_exit(NULL); // 正确：仅结束主线程
}

复制代码

进程终止规则：

exit()立即终止整个进程
主线程return会隐式调用exit()
建议主线程始终利用pthread_exit()

2. 状态接纳机制

(1) 壅闭接纳（Joinable模式）

void* status;
int ret = pthread_join(tid, &status);
if(ret == 0) {
printf("退出码: %d\n", *(int*)status);
free(status); // 必须释放堆内存
}

复制代码

限制条件：

每个线程只能被join一次
已分离线程无法join

(2) 自动接纳（Detached模式）

// 创建时设置分离属性
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, worker, NULL);
// 运行时分离
pthread_detach(existing_tid);

复制代码

特性：

线程终止后自动接纳资源
无法获取返回值
实用于后台任务线程

五、线程资源管理

1. 清算函数机制

void cleanup(void* arg) {
printf("清理资源: %p\n", arg);
free(arg);
}
void* worker(void* arg) {
void* res = malloc(1024);
pthread_cleanup_push(cleanup, res); // 注册清理函数
// 可能被取消的代码段
while(1) {
pthread_testcancel();
/* 临界操作 */
}
pthread_cleanup_pop(1); // 执行清理并出栈
return NULL;
}

复制代码

触发条件：

pthread_cleanup_pop(非零值)
线程通过pthread_exit()退出
被其他线程取消

编码规范：

push/pop必须成对出现
建议在可能被取消的代码段前注册
栈式管理（后进先出）

2. 属性管理

(1) 完备属性设置流程

pthread_attr_t attr;
pthread_attr_init(&attr); // 初始化
// 设置分离状态
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
// 设置栈大小（2MB示例）
size_t stack_size = 2 * 1024 * 1024;
void* stack_addr = malloc(stack_size);
pthread_attr_setstack(&attr, stack_addr, stack_size);
pthread_create(&tid, &attr, worker, NULL);
pthread_attr_destroy(&attr); // 销毁属性

复制代码

(2) 常用属性API

函数功能形貌pthread_attr_setdetachstate设置分离/结合状态pthread_attr_setstacksize设置线程栈巨细pthread_attr_setguardsize设置栈溢出保护区巨细pthread_attr_setschedpolicy设置调度策略（FIFO/RR等）六、线程同步机制

1. 互斥锁完备实现

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_func(void* arg) {
pthread_mutex_lock(&mutex);
/* 临界区操作 */
pthread_mutex_unlock(&mutex);
return NULL;
}
// 动态初始化方式
pthread_mutex_init(&mutex, NULL);
/* ... */
pthread_mutex_destroy(&mutex);

复制代码

2. 同步机制对比

机制实用场景优点缺点互斥锁共享资源访问控制简朴高效可能产生死锁读写锁读多写少场景提高读并发性能写线程可能饿死条件变量线程间状态关照准确唤醒机制需配合互斥锁利用信号量资源数量控制跨进程可用功能相对基础 3. 全局变量竞争办理方案

pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
int global_counter = 0;
void* counter_thread(void* arg) {
for(int i=0; i<100000; ++i) {
pthread_mutex_lock(&mutex);
global_counter++; // 原子操作
pthread_mutex_unlock(&mutex);
}
return NULL;
}

复制代码

优化建议：

尽量减小临界区范围
避免嵌套锁
利用trylock避免死锁

七、高级主题与最佳实践

1. 返回值处理规范

(1) 简朴状态码

// 传递整型值
pthread_exit((void*)(intptr_t)error_code);
// 接收端
int code = (int)(intptr_t)status;

复制代码

(2) 复杂数据结构

struct Result {
int code;
char message[256];
};
void* worker(void* arg) {
struct Result* res = malloc(sizeof(struct Result));
/* 填充数据 */
pthread_exit(res);
}
// 接收端
struct Result* res = (struct Result*)status;
free(res);

复制代码

2. 线程设计准则

资源管理三原则：
- 谁分配谁释放
- 退出前释放非共享资源
- 利用RAII模式管理资源
锁利用规范：
1. // 推荐加锁方式
2. pthread_mutex_lock(&mutex);
3. do {
4. /* 临界区操作 */
5. } while(0);
6. pthread_mutex_unlock(&mutex);
8. // 避免的写法
9. if(condition) pthread_mutex_unlock(&mutex); // 易漏解锁
复制代码
错误处理模板：
1. int ret = pthread_create(&tid, NULL, worker, NULL);
2. if(ret != 0) {
3. fprintf(stderr, "线程创建失败: %s\n", strerror(ret));
4. exit(EXIT_FAILURE);
5. }
复制代码

3. 调试本领

死锁检测：
- 利用pthread_mutex_trylock()测试锁状态
- 记载加锁顺序
- 利用Valgrind的Helgrind工具
性能分析：
1. # 使用perf分析锁竞争
2. perf record -g -- ./program
3. perf report
复制代码

八、完备生命周期图示

graph TD
A[线程创建] --> B{执行阶段}
B -->|正常完成| C[资源回收]
B -->|被取消| D[清理处理]
C --> E[线程终止]
D --> E
E --> F[系统回收TID]
style B fill:#f9f,stroke:#333,stroke-width:2px
style C fill:#9f9,stroke:#333
style D fill:#f99,stroke:#333
subgraph 关键状态
B
C
D
end

复制代码

九、常见标题办理方案

1. 僵尸线程标题

征象：线程终止但未接纳，占用体系资源
办理方案：

// 方案1：及时join
void* retval;
pthread_join(tid, &retval);
free(retval);
// 方案2：设置分离属性
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, worker, NULL);

复制代码

2. 返回值内存泄漏

错误示例：

void* worker() {
int result = 42;
pthread_exit(&result); // 栈内存泄露！
}

复制代码

精确实践：

void* worker() {
int* result = malloc(sizeof(int)); // 堆内存
*result = 42;
pthread_exit(result);
}

复制代码

3. 取消点设置不足

标题表现：取消请求长期不响应
优化方案：

void* worker(void* arg) {
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
while(1) {
pthread_testcancel(); // 每循环添加取消点
/* 长时间操作 */
}
return NULL;
}

复制代码

十、扩展知识

1. 线程与进程对比

特性进程线程资源开销高（独立所在空间）低（共享所在空间）通讯方式管道、共享内存、信号等全局变量、互斥锁、条件变量容错性一个进程瓦解不影响其他线程瓦解导致整个进程终止上下文切换成本高低 2. 可重入函数设计

安全函数特征：

不利用静态变量
不调用非可重入函数
所有数据通过参数传递

示例对比：

// 不安全版本
char* strtok(char* str, const char* delim) {
static char* buffer; // 静态变量
/* ... */
}
// 可重入版本
char* strtok_r(char* str, const char* delim, char** saveptr) {
/* 使用传入的saveptr保存状态 */
}

复制代码

十一、信号量

一、信号量概述

本质：计数器+等候队列，用于控制多线程/进程对共享资源的访问
分类：
- 无名信号量：内存中匿名对象，用于线程间同步
- 有名信号量：文件体系可见，用于进程间同步

二、核心API详解

1. 无名信号量操作

int sem_init(sem_t *sem, int pshared, unsigned int value);

复制代码

pshared：0表示线程间共享，非0表示进程间共享
value：信号量初始值（可用资源数）

2. 有名信号量操作

sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);
int sem_unlink(const char *name); // 删除系统残留信号量

复制代码

3. 通用操作函数

// P操作（申请资源）
int sem_wait(sem_t *sem); // 阻塞等待
int sem_trywait(sem_t *sem); // 非阻塞尝试
// V操作（释放资源）
int sem_post(sem_t *sem);
// 销毁信号量
int sem_destroy(sem_t *sem); // 无名信号量
int sem_close(sem_t *sem); // 有名信号量

复制代码

三、利用框架

// 无名信号量使用流程
sem_t sem;
sem_init(&sem, 0, 1); // 初始化
sem_wait(&sem); // P操作
// 临界区操作...
sem_post(&sem); // V操作
sem_destroy(&sem); // 销毁
// 有名信号量使用流程
sem_t *sem = sem_open("/mysem", O_CREAT, 0644, 1);
sem_wait(sem);
// 临界区操作...
sem_post(sem);
sem_close(sem);
sem_unlink("/mysem"); // 最后使用后删除

复制代码

四、线程同步示例

#include <semaphore.h>
#include <pthread.h>
sem_t sem;
int shared_data;
void* thread_func(void* arg) {
sem_wait(&sem);
// 操作共享资源
shared_data++;
sem_post(&sem);
return NULL;
}
int main() {
sem_init(&sem, 0, 1);
pthread_t tid;
pthread_create(&tid, NULL, thread_func, NULL);
sem_wait(&sem);
printf("Shared data: %d\n", shared_data);
sem_post(&sem);
pthread_join(tid, NULL);
sem_destroy(&sem);
return 0;
}

复制代码

五、线程属性管理

// 设置分离属性
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
// 或在线程创建后设置
pthread_detach(thread_id);
// 主动让出CPU
pthread_yield(); // 或使用 usleep()

复制代码

六、死锁专题

须要条件（需同时满意）：

互斥访问
请求并保持
不可剥夺
循环等候

避免策略：

资源有序分配法
银行家算法
设置超时机制（利用sem_timedwait）
避免嵌套锁申请
利用valgrind等工具检测

七、留意事项

信号量初始值决定举动：
- 二进制信号量：初始值为1
- 计数信号量：初始值>1
必须检查API返回值：
1. if(sem_post(&sem) == -1) {
2. perror("sem_post failed");
3. }
复制代码
销毁前确保：
- 没有线程壅闭在信号量上
- 不能销毁已销毁的信号量
有名信号量的命名：
- 必须以斜杠开头（如"/mysem"）
- 长度限制（通常NAME_MAX-4）

八、补充说明

POSIX vs System V信号量：
- POSIX更轻量，接口更轻便
- System V支持更复杂的控制
信号量与互斥锁的区别：
特性信号量互斥锁所有者无有（锁定线程）可递增值是否跨进程利用支持（有名）一般不支持

练习、创建两个线程，线程1 打印 hello，线程2 打印 world，预期效果在屏幕上严格打印hello world

#include<stdio.h>
#include<pthread.h>
#include<errno.h>
#include<unistd.h>
#include<semaphore.h>
char buf[1024];
sem_t sem_w;
sem_t sem_r;
void *do_something(void *arg)
{
while(1)
{
sem_wait(&sem_w);
printf("hello ");
sem_post(&sem_r);
sleep(1);
}
return NULL;
}
void *do_something1(void *arg)
{
while(1)
{
sem_wait(&sem_r);
printf("world!\n");
sem_post(&sem_w);
sleep(1);
}
return NULL;
}
int main(int argc, const char *argv[])
{
pthread_t tid1, tid2;
int ret, ret1;
sem_init(&sem_w,0,1);
sem_init(&sem_r,0,0);
if ((ret = pthread_create(&tid1, NULL, do_something, NULL)) != 0)
{
errno = ret;
perror("pthread_create for do_something fail");
return -1;
}
if ((ret1 = pthread_create(&tid2, NULL, do_something1, NULL)) != 0)
{
errno = ret1;
perror("pthread_create for do_something1 fail");
return -1;
}
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}

复制代码

十二、练习

练习1：创建一个线程

#include<stdio.h>
#include<pthread.h>
#include<errno.h>
#include<unistd.h>
void * do_something(void *arg)
{
printf("do copy file---\n");
return NULL;
}
int main(int argc, const char *argv[])
{
pthread_t tid;
int ret;
if((ret = pthread_create(&tid,NULL,do_something,NULL)) != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
printf("-----main-------\n");
sleep(1);
return 0;
return 0;
}

复制代码

练习2：创建多个线程

#include<stdio.h>
#include<pthread.h>
#include<errno.h>
#include<unistd.h>
void * do_one(void *arg)
{
printf("pthread 1 pid = %d\n",getpid());
return NULL;
}
void * do_two(void *arg)
{
printf("pthread 2 pid = %d\n",getpid());
return NULL;
}
void * do_three(void *arg)
{
printf("pthread 3 pid = %d\n",getpid());
return NULL;
}
typedef void *(*thread_cb_t)(void*);
int main(int argc, const char *argv[])
{
printf("---main--- pid = %d\n",getpid());
pthread_t tid[3];
int ret;
thread_cb_t func[3] = {do_one,do_two,do_three};
int i = 0;
for(i = 0;i < 3;i++)
{
if((ret = pthread_create(&tid[i],NULL,func[i],NULL)) != 0)
{
errno = ret;
perror("pthread1_create fail");
return -1;
}
}
sleep(1);
return 0;
return 0;
}

复制代码

练习3：线程的关闭

#include<stdio.h>
#include<pthread.h>
#include<errno.h>
#include<unistd.h>
void * do_something(void *arg)
{
static int ret = 100;
printf("do copy file---\n");
//pthread_exit("i am dead\n");
pthread_exit(&ret);
//return NULL;
}
int main(int argc, const char *argv[])
{
pthread_t tid;
int ret;
if((ret = pthread_create(&tid,NULL,do_something,NULL)) != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
printf("-----main-------\n");
int *retval;
//char *retval;
pthread_join(tid,(void **)&retval);
//printf("*retval = %s\n",retval);
printf("*retval = %d\n",*retval);
sleep(1);
return 0;
return 0;
}

复制代码

练习4：多线程拷贝文件（缺陷当文件过大，会导致偏移量出错）

#include <stdio.h>
#include <pthread.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
typedef struct
{
int fd_s;
int fd_d;
int size;
int len;
int id;
}msg_t;
void * do_copy (void *arg)
{
msg_t p = *(msg_t*)arg;
lseek(p.fd_s,p.size*p.id,SEEK_SET);
lseek(p.fd_d,p.size*p.id,SEEK_SET);
// printf("tid = %ld id = %d fd_s = %d fd_d = %d size = %d len = %d\n",pthread_self(),p.id,p.fd_s,p.fd_d,p.size,p.len);//调试代码
char buf[p.len];
int ret = read(p.fd_s,buf,p.len);
write(p.fd_d,buf,ret);
return NULL;
}
//cp src dest
int main(int argc, const char *argv[])
{
if (argc!=3)
{
printf("Usage: %s <src> <dest>\n",argv[0]);
return -1;
}
int fd_s = open(argv[1],O_RDONLY);
int fd_d = open(argv[2],O_WRONLY|O_TRUNC|O_CREAT,0666);
if (fd_s < 0 || fd_d < 0)
{
perror("open fail");
return -1;
}
int n = 0;
printf("Input threads num: ");
scanf("%d",&n);
int i = 0;
int ret = 0;
pthread_t tid[n];
msg_t msg[n];
struct stat st;
if (stat(argv[1],&st) < 0)
{
perror("stat fail");
return -1;
}
int f_len = st.st_size;
for (i = 0; i < n; ++i)
{
msg[i].fd_s = fd_s;
msg[i].fd_d = fd_d;
msg[i].size = f_len / n;
msg[i].id = i;
#if 1
if (i == n-1)
{
msg[i].len = f_len - (f_len/n)*(n-1);
}else
{
msg[i].len = f_len/n;
}
#endif
ret = pthread_create(&tid[i],NULL,do_copy,&msg[i]);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
}
printf("----main-----\n");
for (i = 0; i < n; ++i)
pthread_join(tid[i],NULL);
close(fd_s);
close(fd_d);
return 0;
}

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

Linux----线程

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块