Day07 Liunx高级系统设计8-线程

发布时间:2023年12月18日

概述

进程与线程

进程 : 系统分配资源的基本单位 , 可以简单理解为一个正在进行的程序
线程 : 操作系统调度的最小单位 , 就是一段代码的执行顺序
注意:
1, 一个进程必须要有一个线程 , 该线程被称为主线程
2, 一个进程可以有多个线程 , 除主线程外的其他线程都是子线程
3, 进程被销毁时 , 其中的线程也将被销毁 .
4, 线程是轻量级的进程( LWP light weight process ),在 Linux 环境下线程的本
质仍是进程。
5, 进程所有线程都共享该进程的资源。

线程的特点

Unix 系统中,早期是没有 线程 概念的, 80 年代才引入,借助进程机制实现出了线程的概念。
因此在这类系统中,进程和线程关系密切:
1) 线程是轻量级进程 (light-weightprocess) ,也有 PCB ,创建线程使用的底层函数和进程一样,都是 clone
2) 从内核里看进程和线程是一样的,都有各自不同的 PCB.
3) 进程可以蜕变成线程
4) linux 下,线程最是小的执行单位;进程是最小的分配资源单位
实际上,无论是创建进程的 fork ,还是创建线程的 pthreadcreate ,底层实现都是调用同一个内核函数 clone
????????? 如果复制对方的地址空间,那么就产出一个 进程
????????? 如果共享对方的地址空间,就产生一个 线程
Linux 内核是不区分进程和线程的 , 只在用户层面上进行区分。所以,线程所有操作函数pthread* 是库函数,而非系统调用

线程共享与非共享的资源

共享的
1) 文件描述符表
2) 每种信号的处理方式
3) 当前工作目录
4) 用户 ID 和组 ID
5) 内存地址空间 (.text/.data/.bss/heap/ 共享库 )
非共享的
1) 线程 id
2) 处理器现场和栈指针 ( 内核栈 )
3) 独立的栈空间 ( 用户空间栈 )
4) errno 变量
5) 信号屏蔽字
6) 调度优先级

现成的优缺点

优点
提高程序并发性
开销小
数据通信、共享数据方便
缺点
库函数,不稳定
调试、编写困难、 gdb 不支持
对信号支持不好 优点相对突出,缺点均不是硬伤。 Linux 下由于实现方法导致进程、线程差别不是很大。

查看的指定的线程号(LWP)

ps - Lf? pid

pid : 进程号

注意:

由于线程库原本不是系统本身的 , 所以在链接时需要手动链接库文件 ,编译源文件时输入gcc *.c -l pthread

线程相关函数

获取当前线程号

简述

线程号只在它所属的进程环境中有效。
线程号则用 pthread_t 数据类型来表示, Linux 使用无符号长整数表示。
函数:
所需头文件
????????#include <pthread.h>
函数
????????pthread_t pthread_self(void);
功能:
????????获取线程号。
参数:
????????无
返回值:
????????调用线程的线程 ID
示例:
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
int main()
{
    pthread_t pthid = pthread_self();
    printf("pthid=%ld\n",pthid);
    return 0;
}

创建线程

函数

所需头文件
????????#include <pthread.h>
函数
????????int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
????????void *(*start_routine)(void *), void *arg );
参数:
????????thread:线程标识符地址。
????????attr:线程属性结构体地址,通常设置为 NULL
????????start_routine:线程函数的入口地址。
????????arg:传给线程函数的参数。
返回值:
????????成功:0
????????失败:非 0
示例:
#include <stdio.h>
#include <pthread.h>
// 注意线程调用的函数返回值为任意指针类型
void *myfunc01()
{
    printf("线程%ld正在执行\n", pthread_self());
    return NULL;
}
void *myfunc02(void *arg)
{
    printf("线程%ld正在执行,参数为:%s\n", pthread_self(), (char *)arg);
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_t p1, p2, p3;
    pthread_create(&p1, NULL, myfunc01, NULL);
    pthread_create(&p2, NULL, myfunc02, "Thread2");
    pthread_create(&p3, NULL, myfunc02, "Thread3");
    getchar();
    return 0;
}

线程的回收

作用
等待线程结束(此函数会阻塞),并回收线程资源,类似进程的 wait() 函数。如果线程已经结束,那么该函数会立即返回。
函数
????????#include <pthread.h>
????????int pthread_join(pthread_t thread, void **retval);
参数:
????????thread:被等待的线程号。
????????retval:用来存储线程退出状态的指针的地址 , 即回收的线程调用的函数的返回值
返回值:
????????成功:0
????????失败:非 0
示例:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *myfunc01(void *argv)
{
    int *time = (int *)argv;
    printf("线程A%ld将于%d秒后销毁\n", pthread_self(), *time);
    sleep(*time);
    return "线程A";
}
void *myfunc02(void *argv)
{
    int *time = (int *)argv;
    printf("线程B%ld将于%d秒后销毁\n", pthread_self(), *time);
    sleep(*time);
    return "线程B";
}
int main(int argc, char const *argv[])
{
    int n01 = 3, n02 = 5;
    pthread_t p1, p2;
    pthread_create(&p1, NULL, myfunc01, &n01);
    pthread_create(&p2, NULL, myfunc02, &n02);
    void *argv01, *argv02;
    pthread_join(p1, &argv01);
    pthread_join(p2, &argv02);
    printf("%s被回收\n", (char *)argv01);
    printf("%s被回收\n", (char *)argv02);
    return 0;
}

线程的分离

作用
使调用线程与当前进程分离,分离后不代表此线程不依赖与当前进程,线程分离的目的
是将线程资源的回收工作交由系统自动来完成,也就是说当被分离的线程结束之后,系
统会自动回收它的资源。所以,此函数不会阻塞。
函数
头文件
? ? ? ? #include <pthread.h>
函数
? ? ? ? void pthread_detach(patread_t thread);
参数:
? ? ? ? thread:线程号
示例:
?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *fun1(void *arg)
{
    printf("线程1开始执行\n");
    sleep(3);
    return NULL;
}
void *fun2(void *arg)
{
    printf("线程2开始执行\n");
    sleep(1);
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_create(&tid1,NULL,fun1,NULL);
    pthread_create(&tid2,NULL,fun2,NULL);
    pthread_detach(tid1);
    pthread_detach(tid2);
    getchar();
    return 0;
}

案例1:多线程遍历字符串

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
void *fun(void *arg)
{
    printf("len = %ld\n",strlen(arg));
    char *txt = (char *)arg;
    char buf[32] = {0};
    strcpy(buf,txt);
    printf("线程%ld开始执行\n",pthread_self);
    for(int i = 0;i < strlen(buf);i++)
    {
        printf("%c\n",buf[i]);
        sleep(1);
    }
    printf("线程%ld执行结束\n");
}
int main(int argc, char const *argv[])
{
    char buf[32] = {0};
    while(1)
    {
        // memset(buf,0,32);
        printf("请输入要打印的字符\n");
        fgets(buf,32,stdin);
        buf[strlen(buf)-1] = 0;
        if(strcmp(buf,"886")==0)
        {
            break;
        }    
        
        pthread_t t;
        pthread_create(&t,NULL,fun,buf);
    }
    
    return 0;
}

线程的退出

作用
退出当前线程。一个进程中的多个线程是共享该进程的数据段,因此,通常线程退出后
所占用的资源并不会释放。
函数
所需头文件
????????#include <pthread.h>
函数
????????void pthread_exit(void *retval);
参数:
????????retval:存储线程退出状态的指针。
返回值:
????????无
示例
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *fun(void *arg)
{
    for(int i = 0;i < 10;i++)
    {
        printf("%d\n",i);
        sleep(1);
        if(i == 3)
        {
            pthread_exit(NULL);
        }
    }
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_t tid;
    pthread_create(&tid,NULL,fun,NULL);
    pthread_detach(tid);
    return 0;
}

线程的取消

作用
退出指定线程
注意 :
线程的取消并不是实时的,而有一定的延时。需要等待线程到达某个取消点 ( 检查点)
检测点:类似与游戏的存档,不是实时的,需要到特定的地方才会存档
函数
????????#include <pthread.h>
???????? int pthread_cancel(pthread_t thread);
参数:
? ? ? ? thread :目标线程id
返回值:
? ? ? ? 成功:0
? ? ? ? 失败:出错编号
示例:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *fun(void *arg)
{
    for(int i = 0;i < 10;i++)
    {
        printf("%d\n",i);
        sleep(1);
        
    }
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_t tid;
    pthread_create(&tid,NULL,fun,NULL);
    sleep(3);
    pthread_detach(tid);
    pthread_join(tid,NULL);
    return 0;
}

线程的属性(了解)

概述

Linux 下线程的属性是可以根据实际项目需要,进行设置,之前我们讨论的线程都是采
用线程的默认属性,默认属性已经可以解决绝大多数开发时遇到的问题。
如我们对程序的性能提出更高的要求那么需要设置线程属性,比如可以通过设置线程栈
的大小来降低内存的使用,增加最大线程个数。

线程树形结构体

typedef struct
{
int etachstate ; // 线程的分离状态
int schedpolicy ; // 线程调度策略
struct sched_param schedparam ; // 线程的调度参数
int inheritsched ; // 线程的继承性
int scope ; // 线程的作用域
size_t guardsize ; // 线程栈末尾的警戒缓冲区大小
int stackaddr_set ; // 线程的栈设置
void * stackaddr ; // 线程栈最低地址 , 即线程栈的地址 , 默认是从所
属的进程的栈空间划分
size_t stacksize ; // 线程栈的大小
} pthread_attr_t ;
注意:
1. 线程分离状态
2. 线程栈大小(默认平均分配)
3. 线程栈警戒缓冲区大小(位于栈末尾)
4. 线程栈最低地址
以上属性的属性值不能直接设置,须使用相关函数进行操作,初始化的函数为
pthread_attr_init ,这个函数必须在 pthread_create 函数之前调用。之后须用
pthread_attr_destroy 函数来释放资源。

线程属性相关函数

初始化

作用 :
????????初始化线程属性
函数
????????int pthread_attr_init(pthread_attr_t *attr);
返回值:
????????成功:0
????????失败:错误号

销毁

作用
销毁线程属性
函数
int pthread_attr_destroy(pthread_t *attr);
返回值:
? ? ? ? 成功:0
? ? ? ? 失败:错误号

分离状态

作用 : 设置分离状态
函数
int pthread_attr_setdetachstate(pthread_attr_t?*attr,int detachstate);
参数:
????????attr:已初始化的线程属性
detachstate:
? ? ? ? 分离状态 PTHREAD_CREATE_DETACHED (分离线程)
????????PTHREAD_CREATE_JOINABLE (非分离线程)
作用 : 获取分离状态
int pthread_attr_getdetachstate(pthread_attr_t *attr, int
*detachstat);
参数 :
????????attr:已初始化的线程属性
????????detachstate:
分离状态 PTHREAD_CREATE_DETACHED (分离线程)
PTHREAD_CREATE_JOINABLE (非分离线程)
示例:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *fun(void *arg)
{
    int i = 0;
    while(1)
    {
        printf("%lu正在运行i=%d\n",pthread_self(),i++);
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    pthread_attr_t attr;
    pthread_attr_init (&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);//设置分离属性

    pthread_t tid;
    pthread_create(&tid,NULL,fun,NULL);
    printf("5秒后将结束线程\n");
    sleep(5);
    pthread_cancel(tid);
    sleep(1);
    printf("销毁线程\n");
    pthread_attr_destroy(&attr);
    return 0;
}

线程栈相关

概述:

// 设置栈的地址
int pthread_attr_setstack(pthreadattrt *attr, void *stackaddr, sizet stacksize);
参数:
????????attr:指向一个线程属性的指针
????????stackaddr:设置的栈的地址
????????stacksize:设置的栈的大小
返回值
????????成功:0
;失败:错误号
// 得到栈的地址
int pthread_attr_getstack(pthreadattrt *attr, void **stackaddr, sizet*stacksize);
参数:
????????attr:指向一个线程属性的指针
????????stackaddr:返回获取的栈地址
????????stacksize:返回获取的栈大小
成功: 0 ;失败:错误号
// 设置线程所使用的栈空间大小
int pthread_attr_setstacksize(pthreadattrt *attr, sizet stacksize);
参数:
????????attr:指向一个线程属性的指针
????????stacksize:设置的栈大小
成功: 0 ;失败:错误号
// 得到线程所使用的栈空间大小
int pthread_attr_getstacksize(pthreadattrt*attr, sizet *stacksize);
参数:
????????attr:指向一个线程属性的指针
????????stacksize:获取线程的栈大小
成功: 0 ;失败:错误号
示例:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <
void *fun(void *arg)
{
    int i = 0;
    while(1)
    {
        printf("%lu线程正在执行i=%d\n",pthread_self(),i++);
        sleep(1);
    }
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
    void *stackaddr = calloc(1,128);
    if(stackaddr == NULL)
    {
        perror("null");
        return 0;
    }
    pthread_attr_setstack(&attr,&stackaddr,128);
    pthread_t tid;
    printf("线程在5秒后结束\n");
    pthread_create(&tid,&attr,fun,NULL);
    sleep(5);
    pthread_cancel(tid);
    sleep(1);
    pthread_attr_destroy(&attr);
    free(stackaddr);
    return 0;
}

注意事项

1) 主线程退出其他线程不退出,主线程应调用 pthread_exit
2) 避免僵尸线程
????????a) pthread_join
????????b) pthread_detach
????????c) pthread_create 指定分离属性
join 的线程可能在 join 函数返回前就释放完自己的所有内存资源,所以不应当返回被回收线程栈中的值; 3) malloc mmap 申请的内存可以被其他线程释放
4) 应避免在多线程模型中调用 fork ,除非马上 exec ,子进程中只有调用 fork 的线程存在,其他线程 t 在子进程中均 pthread_exit
5)信号的复杂语义很难和多线程共存,应避免在多线程引入信号机制

案例

火车票售票问题
定义一个记录火车票的剩余数量
4 个窗口同时销售该火车票
代码:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
int ticket = 100;
void *sale(void *name)
{
    char buf[32] = {0};
    strcpy(buf,(char*) name);
    while(ticket > 0)
    {
        ticket--;
        sleep(0.5);
        printf("%s售卖了一张船票,还剩%d张船票\n",buf,ticket);

    }
}
int main(int argc, char const *argv[])
{
    pthread_t tid1,tid2,tid3,tid4;
    pthread_create(&tid1,NULL,sale,"一号窗口");
    pthread_create(&tid2,NULL,sale,"二号窗口");
    pthread_create(&tid3,NULL,sale,"三号窗口");
    pthread_create(&tid3,NULL,sale,"四号窗口");
    pthread_detach(tid1);
    pthread_detach(tid2);
    pthread_detach(tid3);
    pthread_detach(tid4);
    getchar();
    return 0;
}

作业

1, 整理笔记
2, 完成以下情况
????????一个线程打印1~52
????????一个线程打印a~z
3, 使用代码模拟龟兔赛跑
????????乌龟每秒1
????????兔子每秒5
????????赛程100
????????兔子在临近终点睡觉了, 导致乌龟赢了
4, 完成售票案例 , 查看并分析结果 , 说明原因
代码参考上面案例
原因:
是因为卖了第一张票后,其他三个窗口在抢cpu执行权,在第一张票卖出去,提示的信息还未执行的时候,其他三个线程有一个线程有一个将cpu执行权抢了过去,这是票数实际是99,同理以此类推,其他线程将cpu执行权抢了过去,所以将卖了四张票后才第一次打印提示信息,这时实际票数已经是96张,所以,这时提示的信息中将之前的四次卖票纪律一次性打出来了,所以都是剩余96张。总之,这是个异步,在栈中,每个线程都将有各自独立的ticket,都是100张。
解决办法:
是要解决其中异步的问题,所以要解决这一问题,就是要实现同步,让四个线程只对一个ticket操作就可以。
简单的可以用将ticket设置为全局变量
文章来源:https://blog.csdn.net/aisheisadas/article/details/134950038
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。