Linux----线程

发布于：2025-02-25 ⋅ 阅读:(24) ⋅ 点赞:(0)

一、基础概念对比

特性 进程 (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);
参数详解表
参数 类型 作用说明
thread pthread_t* 输出参数，存储新线程ID
attr pthread_attr_t* 线程属性（NULL使用默认属性）：<br>▪ 栈大小<br>▪ 调度策略<br>▪ 分离状态
start_routine void* (*)(void*) 线程入口函数（返回值为线程退出状态）
arg void* 传递给入口函数的参数
返回值
  • 成功返回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;
}

触发条件：

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

编码规范：

  • 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. 线程设计准则

  1. 资源管理三原则：

    • 谁分配谁释放
    • 退出前释放非共享资源
    • 使用RAII模式管理资源

  2. 锁使用规范：

    // 推荐加锁方式
pthread_mutex_lock(&mutex);
do {
    /* 临界区操作 */
} while(0);
pthread_mutex_unlock(&mutex);

// 避免的写法
if(condition) pthread_mutex_unlock(&mutex);  // 易漏解锁

  3. 错误处理模板：

    int ret = pthread_create(&tid, NULL, worker, NULL);
if(ret != 0) {
    fprintf(stderr, "线程创建失败: %s\n", strerror(ret));
    exit(EXIT_FAILURE);
}

3. 调试技巧

  1. 死锁检测：

    • 使用pthread_mutex_trylock()测试锁状态
    • 记录加锁顺序
    • 使用Valgrind的Helgrind工具

  2. 性能分析：

    # 使用perf分析锁竞争
perf record -g -- ./program
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保存状态 */
}

十一、信号量

一、信号量概述

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

二、核心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()

六、死锁专题

必要条件（需同时满足）：
  1. 互斥访问
  2. 请求并保持
  3. 不可剥夺
  4. 循环等待
避免策略：
  • 资源有序分配法
  • 银行家算法
  • 设置超时机制（使用sem_timedwait）
  • 避免嵌套锁申请
  • 使用valgrind等工具检测

七、注意事项

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

八、补充说明

  1. POSIX vs System V信号量：

    • POSIX更轻量，接口更简洁
    • System V支持更复杂的控制

  2. 信号量与互斥锁的区别：

    特性 信号量 互斥锁
    所有者 无 有（锁定线程）
    可递增值 是 否
    跨进程使用 支持（有名） 一般不支持

练习、创建两个线程，线程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;
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布