linux线程-CSDN博客

本文链接：https://blog.csdn.net/weixin_59141187/article/details/131225829

linux线程

线程的概述
线程与互斥锁
线程与条件

线程的概述

就像每个进程都有一个进程号一样，每个线程也有一个线程号。进程号在整个系统中是唯一的，但线程号不同，线程号只在它所属的进程环境中有效。
进程号用 pid_t 数据类型表示，是一个非负整数。线程号则用 pthread_t 数据类型来表示，Linux 使用无符号长整数表示。
进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。线程共享进程的内存空间。
在一个进程内部，有时不一定只有一个执行流，在多执行流下，多个执行流共享了进程的地址空间，我们把“一个程序内部的控制序列”叫做线程。。
在现实生活中，假如我们把社会资源的基本单位看作是家庭，比如我们经常以家庭年收入统计社会财富的分配状况，那么此时：
- 操作系统—>社会
- 进程—>家庭
- 线程—>家庭成员

线程开发在 Linux 平台上已经有成熟的 pthread 库支持。其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。
其中，线程操作又分线程的创建，退出，等待 3 种。
互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。
条件操作有 5 种操作：创建，销毁，触发，广播和等待。
其他的一些线程扩展概念，如信号灯等，都可以通过上面的三个基本元素的基本操作封装出来。详细请见下表：
在这里插入图片描述
【注意】线程函数的程序在 pthread 库中，故链接时要加上参数 -lpthread。

线程创建（pthread_create函数）

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void*), void *arg);

thread:返回线程ID，这是进程地址空间的共享区的地址
attr:设置线程的属性，attr为NULL表示使用默认属性
start_routine:是个函数地址，线程启动后要执行的函数
arg:传给线程启动函数的参数，如果需要传入多个参数，可以用结构体封装

返回：若成功返回0，否则返回错误编号

获取线程ID（pthread_ self函数）

pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。

前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。

pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。

线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID：

#include <pthread.h>
pthread_t pthread_self(void);
// 返回：调用线程的ID

线程等待（pthread_join函数）

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号

调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。如果例程只是从它的启动例程返回i，rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。

如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。

示例代码1：（创建获取等待）

#include <stdio.h>
#include <pthread.h>
 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
 
void *func1(void *arg)//线程调用函数
{
   // pthread_t pthread_self(void);// 返回：调用线程的ID
   //获取线程
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());

    printf("t1:param is %d\n",*((int *)arg));//打印int param = 100;执行参数
 
 
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    //1创建线程
    ret = pthread_create(&t1, NULL, func1,(void *)&param);//func1：线程调用函数
    if(ret == 0){
        printf("main:create t1 success\n");//创建线程t1
    }
 
    //2获取线程
    printf("main:%ld\n",(unsigned long)pthread_self());

    //3等待线程
    pthread_join(t1,NULL);
 
    return 0;
}

说明：编译的时候后面加 -pthread ；
运行结果：
在这里插入图片描述

线程退出（pthread_exit函数）

单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：

1）线程只是从启动例程中返回，返回值是线程的退出码。

2）线程可以被同一进程中的其他线程取消。

3）线程调用pthread_exit：

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

rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

示例代码2：（创建获取等待退出返回值）

退出返回值：10。

#include <stdio.h>
#include <pthread.h>
 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
 
void *func1(void *arg)//线程调用函数
{
    static int ret = 10;//退出返回值
 
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t1:param is %d\n",*((int *)arg));///打印int param = 100;执行参数
 
    pthread_exit((void *)&ret);//线程退出  //可以通过调用pthread_join函数访问到这个指针。
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
 
    int *pret = NULL;//定义退出函数指针
  //1创建线程
    ret = pthread_create(&t1, NULL, func1,(void *)&param);//func1：线程调用函数
    if(ret == 0){
        printf("main:create t1 success\n");
    }
 
 //2获取线程
    printf("main:%ld\n",(unsigned long)pthread_self());
 
  //3等待线程
    pthread_join(t1,(void **)&pret);//访问pthread_exit()函数  这里访问的是二级指针
 
    printf("main: t1 quit: %d\n",*pret);
 
    return 0;
}

运行结果：
在这里插入图片描述

示例代码3：（创建获取等待退出返回字符）

退出返回一段字符串。

#include <stdio.h>
#include <pthread.h>
 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
 //func1：线程调用函数
void *func1(void *arg)
{
    static char *p = "t1 is run out";//退出返回字符串
 
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t1:param is %d\n",*((int *)arg));///打印int param = 100;执行参数
 
    pthread_exit((void *)p);
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
 
    char *pret = NULL;
 
    ret = pthread_create(&t1, NULL, func1,(void *)&param);//func1：线程调用函数
    if(ret == 0){
        printf("main:create t1 success\n");
    }
 
 
    printf("main:%ld\n",(unsigned long)pthread_self());
 
    pthread_join(t1,(void **)&pret);
 
    printf("main: t1 quit: %s\n",pret);
 
    return 0;
}

运行结果：

在这里插入图片描述

示例代码3：（创建获取等待执行退出）

线程共享进程的内存空间：定义一个变量 t1 t2 main()三个线程分别进行访问(谁先访问谁后访问都是随机的)

#include <stdio.h>
#include <pthread.h>
 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;//定义一个全局（共享）变量  t1 t2 main()三个线程分别进行访问(谁先谁后都是随机的)
  
void *func1(void *arg)//线程t1
{
    //获取t1的线程ID
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t1:param is %d\n",*((int *)arg));//打印int param = 100;执行参数
    while(1){
 
        printf("t1: %d\n",g_data++);    //t1访问g_data
        sleep(1);
 
        if(g_data == 3){
            pthread_exit(NULL);
        }
    }
 
}
 
void *func2(void *arg)//线程t2
{
    //获取t2的线程ID
    printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t2:param is %d\n",*((int *)arg));///打印int param = 100;执行参数
    while(1){
 
        printf("t2: %d\n",g_data++);      //t2访问g_data
        sleep(1);
    }
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
 //创建线程t1
    ret = pthread_create(&t1, NULL, func1,(void *)&param);
    if(ret == 0){
        printf("main:create t1 success\n");
    }
  //创建线程t2
    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
        printf("main:create t2 success\n");
    }
 //获取main()的ID
    printf("main:%ld\n",(unsigned long)pthread_self());  
    while(1){
     
        printf("main: %d\n",g_data++);    //main()访问g_data
        sleep(1);
    }
 //等待
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
 
    return 0;
}

线程与互斥锁

互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。
对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

创建互斥锁(pthread_mutex_init函数)

销毁互斥锁(pthread_mutex_destroy函数)

互斥变量用pthread_mutex_t数据类型表示

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);

返回：若成功返回0，否则返回错误编号
要用默认的属性初始化互斥量，只需把attr设置为NULL。

加锁及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);//
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
// 返回：若成功返回0，否则返回错误编号

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

加锁可以保证这个锁里面的程序先运行完以后其它的线程才可以运行。

示例代码4-(创建加锁解锁)

加锁可以保证这个锁里面的程序先运行完以后其它的线程才可以运行。


#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;
pthread_mutex_t mutex;//定义全局的互斥变量类型
 
void *func1(void *arg)
{
    int i;
 
    pthread_mutex_lock(&mutex);//加锁 // 可以保证这个里面的程序先运行完以后其它的线程才可以运行
    for(i=0;i<5;i++){
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);//解锁
 
}
 
void *func2(void *arg)
{
 
    pthread_mutex_lock(&mutex);//加锁
 
    printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t2:param is %d\n",*((int *)arg));
 
    pthread_mutex_unlock(&mutex);//解锁
 
}
 
void *func3(void *arg)
{
 
    pthread_mutex_lock(&mutex);//加锁
 
    printf("t3:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t3:param is %d\n",*((int *)arg));
 
    pthread_mutex_unlock(&mutex);//解锁
 
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
    pthread_t t3;
 
    //创建互斥锁
    pthread_mutex_init(&mutex, NULL);
 
     //创建线程t1
    ret = pthread_create(&t1, NULL, func1,(void *)&param);
    if(ret == 0){
        printf("main:create t1 success\n");
    }
    //创建线程t2
    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
        printf("main:create t2 success\n");
    }
    //创建线程t3
    ret = pthread_create(&t3, NULL, func3,(void *)&param);
    printf("main:%ld\n",(unsigned long)pthread_self());
     //等待
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    //销毁互斥锁
    pthread_mutex_destroy(&mutex);
 
    return 0;
}

运行结果：
在这里插入图片描述

示例代码5-(共享资源加锁和解锁)


#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include<stdlib.h>
 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;
 
pthread_mutex_t mutex;//定义全局的互斥变量类型
 
 
void *func1(void *arg)
{
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t1:param is %d\n",*((int *)arg));
     
     //加锁
    pthread_mutex_lock(&mutex);
    while(1)
    {
        printf("t1: %d\n",g_data++);    
        sleep(1);
        if(g_data == 3)
        {
            //解锁
            pthread_mutex_unlock(&mutex);
            printf("t1 quit================================\n");
//          pthread_exit(NULL);
            exit(0);
        }
    }
 
}
 
void *func2(void *arg)
{
    printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t2:param is %d\n",*((int *)arg));
     
    while(1){
 
        printf("t2: %d\n",g_data);
        pthread_mutex_lock(&mutex);//加锁 
        g_data++;
        pthread_mutex_unlock(&mutex); //解锁  
        sleep(1);
    }
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;

    //创建初始化互斥锁
    pthread_mutex_init(&mutex,NULL);
 
    ret = pthread_create(&t1, NULL, func1,(void *)&param);
    if(ret == 0)
    {
        printf("main:create t1 success\n");
    }
 
    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0)
    {
        printf("main:create t2 success\n");
    }

    printf("main:%ld\n",(unsigned long)pthread_self());
    while(1)
    {
        printf("main: %d\n",g_data);    
        sleep(1);
    }
 
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
     //销毁互斥锁
    pthread_mutex_destroy(&mutex);
 
    return 0;
}

实验说明：本程序一次只能执行一次，如果要一次运行多次执行的话可以写一个运行脚本。通过实验发现每次执行 t1 的值都不会改变。不会被其它线程夺取。

运行脚本执行代码5

运行脚本编写 : 以上程序执行5次
第一种方法：
创建一个 test.sh文件，内容写要执行的程序本次要执行的程序为 ./a.out ，需要执行5次就重复写5次。
在这里插入图片描述
然后输入 chmod +x test.sh 命令编译，然后在输入 ./test.sh 命令运行。

第二种方法：
创建一个 test.c文件，内容写用for循环，循环执行5次。

然后输入 gcc test.c -o test 命令编译，然后在输入 ./test 命令运行。
在这里插入图片描述

线程与条件

条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。
条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。

创建条件变量(pthread_cond_init函数)

销毁条件变量(pthread_cond_destroy函数）

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);

返回：若成功返回0，否则返回错误编号
除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。

等待(pthread_cond_wait函数）

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, cond struct timespec *restrict timeout);

返回：若成功返回0，否则返回错误编号

pthread_cond_wait等待条件变为真。如果在给定的时间内条件不能满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作都是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。
pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待的时间，它是通过timespec结构指定。

触发(pthread_cond_signal函数）

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
// 返回：若成功返回0，否则返回错误编号

这两个函数可以用于通知线程条件已经满足。
pthread_cond_signal函数将唤醒等待该条件的某个线程，
pthread_cond_broadcast函数将唤醒等待该条件的所有进程。
注意一定要在改变条件状态以后再给线程发信号。

示例代码6-条件满足执行

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>

 
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;
 
pthread_mutex_t mutex;//定义一个互相类型的变量
pthread_cond_t cond;//定义一个条件类型的变量
 
void *func1(void *arg)
{
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t1:param is %d\n",*((int *)arg));

    static int cnt = 0;
     
    while(1)
    {
        //等待pthread_cond_signal(&cond);//触发
        //相当于t2运行3次 t1运行一次
        pthread_cond_wait(&cond,&mutex);//等待触发
        printf("t1 run================================\n");
 
        printf("t1: %d\n",g_data);  

        g_data = 0;

        sleep(1);

        // t1运行6次后退出程序//如果使用脚本循环执行注释该段代码
        if(cnt++ == 5)
        {
            exit(1);
        }
    }
 
}
 
void *func2(void *arg)
{
    printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t2:param is %d\n",*((int *)arg));
     
     
    while(1){
 
        printf("t2: %d\n",g_data);
        //加锁
        pthread_mutex_lock(&mutex);
        g_data++;
        if(g_data == 3)
        {
            //
            pthread_cond_signal(&cond);//触发  触发以后唤醒pthread_cond_wait(&cond,&mutex);
        }
        pthread_mutex_unlock(&mutex);   
        sleep(1);
    }
}
 
int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;

    // 初始化
    pthread_mutex_init(&mutex,NULL);//初始化互斥
    pthread_cond_init(&cond,NULL);//初始化条件
 
 
    ret = pthread_create(&t1, NULL, func1,(void *)&param);
    if(ret == 0){
//      printf("main:create t1 success\n");
    }
 
    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
//      printf("main:create t2 success\n");
    }
 
//  printf("main:%ld\n",(unsigned long)pthread_self());
 
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
 
    //销毁
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

运行结果：
在这里插入图片描述

运行脚本执行代码6

也可以制作此代码测试文件：

创建一个 test1.c文件，内容写用for循环，循环次数可通过命令输入。
在这里插入图片描述
运行过程：

运行后：程序会卡死在那儿，按键盘Ctrl+c和Ctrl+z 然后输入： ./test1 3 >>test.ret.txt &(加上取地址符&）回车可获取进程ID。

宏初始化

pthread_mutex_t mutex;//定义一个互相类型的变量
pthread_cond_t cond;//定义一个条件类型的变量
上面代码可用宏初始化如下：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

pthread_cond_t cond; 
//动态初始化： pthread_cond_init(&cond, NULL);
//静态初始化: pthread_cond_t = PTHREAD_COND_INITIALIZER;

pthread_mutex_t;
//动态初始化: pthread_mutex_init(&mutex,NULL);
//静态初始化: pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER;

宏初始化参考：https://www.cnblogs.com/keep–fighting/p/15489807.html