Linux软件编程(7)—线程（2）

原创已于 2025-08-18 13:37:37 修改 · 756 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#linux #运维 #服务器

于 2025-08-17 21:14:21 首次发布

一、线程传参

可以通过pthread_create第四个参数实现对线程内部的传参

#include "../head.h"
/* 线程参数类型 */
typedef struct pthread_arg
{
pthread_t tid; //存放线程ID
char threadname[32]; //线程名称
int sleeptime; //睡眠时间
}pthread_arg_t;
void *thread(void *arg)
{
pthread_arg_t *parg = arg;
printf("%s(TID:%#lx)开始执行\n", parg->threadname, parg->tid);
while (1)
{
printf("%s正在执行\n", parg->threadname);
sleep(parg->sleeptime);
}
return NULL;
}
int main(void)
{
int i = 0;
pthread_arg_t args[4] = {
{0, "采集线程", 1},
{0, "存储线程", 2},
{0, "显示线程", 5},
{0, "日志线程", 10},
};
for (i = 0; i < 4; i++)
{
pthread_create(&args[i].tid, NULL, thread, &args[i]);
}
for (i = 0; i < 4; i++)
{
pthread_join(args[i].tid, NULL);
}
return 0;
}

二、线程属性

1.加入属性：线程结束需要pthread_join手动回收

分离属性：线程结束后系统自动回收线程空间

2.函数接口

（1）pthread_attr_init

原型：int pthread_attr_init(pthread_attr_t *attr);
功能：
线程属性初始化
参数：
attr:线程属性空间的首地址

（2）pthread_attr_setdetachstate

原型：int pthread_attr_setdetachstate(pthread_attr_t *attr, int
detachstate);
功能：
将线程属性设置为分离属性
参数：
attr:线程属性空间的首地址
detachstate:属性
PTHREAD_CREATE_DETACHED 分离属性
PTHREAD_CREATE_JOINABLE 加入属性

（3）pthread_attr_destroy

原型：int pthread_attr_destroy(pthread_attr_t *attr);
功能：
线程属性销毁
参数：
attr:线程属性空间的首地址

e.g.

#include "../head.h"

void *thread1(void *arg)
{
    sleep(5);
    printf("线程1结束\n");

    return NULL;
}
void *thread2(void *arg)
{
    printf("线程2结束\n");

    return NULL;
}

int main(void)
{
    pthread_t tid[2];
    int i = 0;
    void *(*p[2])(void *) = {thread1, thread2};
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    for(i = 0; i < 2; i++)
    {
        pthread_create(&tid[i], &attr, p[i], NULL);
    }

    pthread_attr_destroy(&attr);

    while(1)
    {

    }

    return 0;
}

3.区别

（1）分离属性：

线程结束后，操作系统自动回收空间

不需要手动调用pthread_join回收线程空间

（2）加入属性：

可以回收到线程结束的状态

可以完成线程间的同步

三、线程间通信

1.方式

采用全局变量

原因：

进程是操作系统资源分配的最小单元

每个进程空间独立的，包含文本段+数据段（全局变量）+系统数据段

一个进程中的多个线程独享栈空间，文本段、数据段、堆区进程多线程共享

注意：多线程同时操作共享空间会引发资源竞争，需要加上互斥锁解决资源竞争问题

2.互斥锁

（1）概念

解决资源竞争的一种方式，可以看成是一种资源。

只能加锁一次，加锁期间不能再次加锁，也不能强制占有一个已经加锁的锁资源，必须等待锁

资源释放，也就是解锁后才能继续操作该锁

加锁和解锁中间的代码称为临界代码，也称为临界区

只能防止多个线程对资源的竞争，不能决定代码的先后执行顺序

原子操作：CPU执行原子操作时无法切换调度任务

（2）使用方式：

①定义互斥锁（全局变量）

②对锁初始化

③操作全局资源前先加锁

④如果加锁成功则完成对全局资源操作

⑤如果加锁失败则表示有人占用资源，必须等待其余人释放锁资源才能加锁成功

⑥直到加锁成功使用该全局资源

（3）函数接口

①pthread_mutex_init

原型：int pthread_mutex_init(pthread_mutex_t *restrict mutex, const
pthread_mutexattr_t *restrict attr);
功能：
初始化互斥锁
参数:
mutex:互斥锁空间首地址
attr:属性，默认为NULL
返回值：
成功返回0
失败返回-1

②pthread_mutex_lock

原型：int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：
互斥锁加锁

③pthread_mutex_unlock

原型：int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：
互斥锁解锁

④ pthread_mutex_destroy

原型：int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：
互斥锁销毁

4.死锁

（1）概念

多线程由于加锁解锁错误导致程序无法继续向下运行的状态称为死锁状态，简称为死锁

（2）死锁产生的四个必要条件：

互斥条件

不可剥夺条件

请求保持条件

循环等待条件

（3）如何避免死锁：

加锁顺序保持一致

使用pthread_mutex_trylock替换pthread_mutex_lock

四、信号量

1. 概念：

信号量是一种资源

信号量只能完成四种操作：初始化、销毁、申请、释放

如果信号量资源数为0，申请资源会阻塞等待，直到占用资源的任务释放资源，资源数不为0时

才能申请到资源并继续向下执行

释放资源不会阻塞

2.函数接口

（1）sem_init

原型：int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：
初始化信号量
参数：
sem:信号的空间的首地址
pshared:
0：一个进程的多个线程间共享
非0:多个进程间共享
value:
初始化的资源的值
返回值：
成功返回0
失败返回-1

(2)sem_destroy

原型：int sem_destroy(sem_t *sem);
功能：
销毁信号量
参数：
sem:信号量空间的首地址
返回值:
成功返回0
失败返回-1

(3)sem_wait

原型：int sem_wait(sem_t *sem);
功能：
申请信号量
参数：
sem:信号量空间首地址
返回值:
成功返回0
失败返回-1

注意：

申请信号量会让信号量资源数-1

如果信号量资源数为0，则会阻塞等待，直到有任务释放资源，才能拿到资源并继续向下执行

(4)sem_post

原型：int sem_post(sem_t *sem);
功能：
释放信号量
参数：
sem:信号量空间首地址
返回值:
成功返回0
失败返回-1

e.g.

#include "../head.h"

char tmpbuff[4096] = {0};
sem_t sem_r;
sem_t sem_w;

void *thread1(void *arg)
{
    while(1)
    {
        sem_wait(&sem_w);
        m_fgets(tmpbuff);
        sem_post(&sem_r);
        if(0 == strcmp(tmpbuff, ".quit"))
        {
            break;
        }
    }

    return NULL;
}

void *thread2(void *arg)
{
    while(1)
    {
        sem_wait(&sem_r);
        printf("tmpbuff = %s\n", tmpbuff);
        if(0 == strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        sem_post(&sem_w);
    }

        return NULL;
}

int main(void)
{
    pthread_t tid1;
    pthread_t tid2;

    sem_init(&sem_r, 0, 0);
    sem_init(&sem_w, 0, 1);
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    sem_destroy(&sem_w);
    sem_destroy(&sem_r);

    return 0;
}