【Linux操作系统】线程控制

已于 2024-09-06 21:02:58 修改
阅读量1k 收藏 27
点赞数 22
分类专栏： Linux 文章标签： linux 运维 服务器 c++ 开发语言
于 2024-09-05 08:42:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77459845/article/details/141889364
版权

目录

一、线程创建

使用接口pthread_create创建新线程，头文件是pthread.h
在这里插入图片描述

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

void* newthreadrun(void* arg)
{
    while(true)
    {
        cout << "I am new thread" << endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    while(true)
    {
        cout << "I am main thread" << endl;
        sleep(1);
    }
    return 0;
}

主线程和新线程的pid是一样的，因为属于同一个进程；要查看线程的id，可以获取变量tid打印出来，这个是新线程的id返回给主线程；如果要像getpid一样获取自己的id，可以使用接口pthread_self
在这里插入图片描述

string Tohex(pthread_t tid)
{
    char id[1024];
    snprintf(id, sizeof(id), "0x%lx", tid);
    return id;
}
void* newthreadrun(void* arg)
{
    int cnt = 5;
    while(cnt)
    {
        cout << "I am new thread, cnt: "<<cnt <<" pid: "<< getpid()<<" threadid: "<<
        Tohex(pthread_self())<< endl;
        sleep(1);
        cnt--;
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    int cnt = 10;
    while(cnt)
    {
        cout << "I am main thread, cnt: "<< cnt <<" pid: "<<getpid()<< " tid: "<<
        Tohex(tid)<<" threadid: "<<Tohex(pthread_self())<<endl;
        sleep(1);
        cnt--;
    }
    return 0;
}

在这里插入图片描述
创建线程的接口的第四个参数可以传参，传入一个字符串作为新线程的名字，注意类型转换。
在这里插入图片描述
在这里插入图片描述
新线程与主线程谁先运行？不确定，由调度器决定
如果主线程先退出，那么其他的线程都要退出，因为主线程等于进程，进程退出了所有的资源要释放，而所有的线程是共享这些资源的。

把主线程的cnt改为1秒，1秒后新线程也退出
在这里插入图片描述
所以一般情况下，往往是主线程最后一个退出，线程也要wait，否则会出现资源泄漏问题。

二、线程等待

使用线程等待的接口：
在这里插入图片描述
主线程进行等待，直到其他线程结束才退出

代码：

	int n = pthread_join(tid, nullptr);
    cout << "主线程退出..., n = " << n << endl;
    sleep(4);

在这里插入图片描述
第二个参数可以获取线程的退出信息
在这里插入图片描述
在这里插入图片描述

三、线程退出

一个进程里面的资源，是所有线程可以共享的。定义一个全局变量，主线程和新线程都可以看到。

int g_val = 100;
void *newthreadrun(void *args)
{
    string threadname = (char *)args;
    while (true)
    {
        printf("g_val: %d, &g_val: %p\n", g_val, &g_val);
        sleep(1);
        g_val++;
    }
    return (void *)123;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthreadrun, (void *)"thread-1");
    while (true)
    {
        printf("g_val: %d, &g_val: %p\n", g_val, &g_val);
        sleep(1);
    }
    void *ret = nullptr;
    int n = pthread_join(tid, &ret);
    cout << "主线程退出..., n = " << n << " ret: " << (long long)ret << endl;
    sleep(4);
    return 0;
}

在这里插入图片描述
如果任何一个线程出现问题，比如出现了野指针，那么整个进程都会被终止

void *newthreadrun(void *args)
{
    string threadname = (char *)args;
    int cnt = 1;
    while (true)
    {
        printf("g_val: %d, &g_val: %p\n", g_val, &g_val);
        sleep(1);
        if(cnt == 5)
        {
            int* p = nullptr;
            *p = 10;
        }
        g_val++;
        cnt++;
    }
    return (void *)123;
}

在这里插入图片描述
野指针错误是异常信号，也就是说，一旦产生信号，整个进程都会被干掉。

线程退出有三种方式：return、pthread_exit、pthread_cancel
1️⃣return
返回退出码
在这里插入图片描述

2️⃣pthread_exit
在这里插入图片描述
在新线程中设置pthread_exit
在这里插入图片描述
3秒后新线程退出，主线程还在
在这里插入图片描述

3️⃣pthread_cancel
在这里插入图片描述
指定新线程3秒后退出，主线程继续运行
在这里插入图片描述
在这里插入图片描述

四、线程的优缺点

优点：

  • 创建一个新线程的代价要比创建一个新进程小得多
  • 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
  • 线程占用的资源要比进程少很多
  • 能充分利用多处理器的可并行数量
  • 在等待慢速 I/O 操作结束的同时，程序可执行其他的计算任务
  • 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
  • I/O 密集型应用，为了提高性能，将 I/O 操作重叠。线程可以同时等待不同的I/O 操作

缺点：

  • 性能损失。一个很少被外部事件阻塞的计算密集型线程往往无法与其它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
  • 健壮性降低。编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的
  • 缺乏访问控制。进程是访问控制的基本粒度，在一个线程中调用某些 OS 函数会对整个进程造成影响

为什么线程切换与进程切换相比需要操作系统做到工作少了很多？
在这里插入图片描述
进程运行时，CPU读取进程的上下文信息，用内部的寄存器进行读取。有一个寄存器CR3是指向页表的首地址。读取方式：用地址空间的虚拟地址通过页表映射得到物理内存的数据，然后交给CPU。

线程是进程的其中一个执行流，CPU也要做相同类似的工作，线程切换也要保存上下文数据，只是比进程少一点。进程切换，每次CPU处理某条代码都要到内存中读取，得到数据后，到下一条代码又要做同样的工作，这样效率就低了一些。而线程也要到内存中读取，但是在CPU中，有一个硬件设备叫cache，作用是可以将当前读到的代码的周围其他代码和数据也一并交给CPU，这样下次遇到时，就可以直接在CPU处理了，效率提高了一些，工作也就少了。

那为什么线程可以这样，进程不行呢？因为进程切换时CPU内部的cache的上下文数据也要跟着切换，即清空掉然后换新的一批。线程不一样是因为多个线程在一个进程内部，每个线程是一个进程的其中一个执行流，进程的所有资源（地址空间、页表、内存）都是可以给这些线程共享的，所以线程切换时，cache里面的上下文数据还在。

线程私有：

  1. 线程的硬件上下文（CPU寄存器的值）
  2. 线程的独立栈结构

线程共享：

  1. 代码和全局数据
  2. 进程文件描述符表

线程安全问题：一个线程出问题，导致其他线程也出问题，整个进程就会退出
公共函数被重入：多线程中，函数被多个线程同时进入

五、多线程的创建

用for循环5次，创建5个线程，然后打印它们的名字

const int threadnum = 5;
void* taskthread(void* args)
{
    char* threadname = static_cast<char*>(args);
    while(true)
    {
        cout << threadname << endl;
        sleep(2);
    }
    delete []threadname;
    return nullptr;
}
int main()
{
    vector<pthread_t> threads;
    for(int i=0;i<threadnum;i++)
    {
        char threadname[64];
        snprintf(threadname, sizeof(threadname), "thread-%d", i+1);

        pthread_t tid;
        pthread_create(&tid, nullptr, taskthread, threadname);
        threads.push_back(tid);
    }

    for(auto e:threads)
    {
        pthread_join(e, nullptr);
    }
    return 0;
}

在这里插入图片描述
发现后面都变成5了，因为这些线程用的是同一个缓冲区，所以后面的线程名字把前面的覆盖了。

修改：每个线程有自己的空间
在这里插入图片描述
在这里插入图片描述

pthread_create的第四个参数不仅可以传递整型变量，还可以传对象，自定义的类型

让线程完成加法：

class Task
{
public:
    Task()
    {}
    void SetData(int x, int y)
    {
        _x = x;
        _y = y;
    }
    int Excute()
    {
        return _x + _y;
    }
    ~Task()
    {}
private:
    int _x;
    int _y;
};
class DataThread
{
public:
    DataThread(int x, int y, const string& threadname)
        :_threadname(threadname)
    {
        _t.SetData(x, y);
    }
    int run()
    {
        return _t.Excute();
    }
    string getName()
    {
        return _threadname;
    }
    ~DataThread()
    {}
private:
    Task _t;
    string _threadname;
};
const int threadnum = 5;
void* taskthread(void* args)
{
    DataThread* td = static_cast<DataThread*>(args);
    string threadname = td->getName();
    int ret = td->run();
    cout << threadname<<" ret is: " <<ret<<endl;
    delete td;
    return nullptr;
}
int main()
{
    vector<pthread_t> threads;
    for(int i=0;i<threadnum;i++)
    {
        char threadname[64];
        snprintf(threadname, sizeof(threadname), "thread-%d", i+1);
        DataThread* td = new DataThread(10, 20, threadname);

        pthread_t tid;
        pthread_create(&tid, nullptr, taskthread, td);
        threads.push_back(tid);
    }

    for(auto e:threads)
    {
        pthread_join(e, nullptr);
    }
    return 0;
}

在这里插入图片描述

六、C++11的多线程

C++11的多线程是对原生线程的封装，为了语言的跨平台性

void newthread(int num)
{
    while (true)
    {
        cout << "I am new thread-" << num << endl;
        sleep(1);
    }
}
int main()
{
    thread t1(newthread, 1);
    thread t2(newthread, 2);
    thread t3(newthread, 3);
    while (true)
    {
        cout << "I am main thread-" << endl;
        sleep(1);
    }
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

在这里插入图片描述

对原生线程做封装：

#ifndef __THREAD_HPP__
#define __THREAD_HPP__
#include <iostream>
#include <string>
#include <vector>
#include <pthread.h>
#include <unistd.h>
#include <functional>

using namespace std;

namespace yss
{
    template <class T>
    using func_t = function<void(T &)>;

    template <class T>
    class Thread
    {
    public:
        void Excute()
        {
            _func(_data);
        }
        Thread(func_t<T> func, const T &data, const string &threadname)
            : _func(func), _data(data), _threadname(threadname), _stop(true)
        {
        }
		// 注意static
        static void *runthread(void *args) // 类成员函数，形参有this指针
        {
            Thread<T> *self = static_cast<Thread<T> *>(args);
            self->Excute();
            return nullptr;
        }
		// 创建
        bool Satrt()
        {
            int n = pthread_create(&_tid, nullptr, runthread, this);
            if (!n) // 创建成功
            {
                _stop = false;
                return true;
            }
            else
            {
                return false;
            }
        }
		// 分离
        void Detach()
        {
            if (!_stop)
            {
                pthread_detach(_tid);
            }
        }
		// 等待
        void Join()
        {
            if (!_stop)
            {
                pthread_join(_tid, nullptr);
            }
        }

        void Stop()
        {
        	_stop = true;
        }
        string name()
        {
            return _threadname;
        }

        ~Thread()
        {
        }

    private:
        pthread_t _tid;
        string _threadname;
        bool _stop;
        func_t<T> _func;
        T _data;
    };
}
#endif

在这里插入图片描述

七、线程分离

默认情况下，新创建的线程是 joinable 的，线程退出后，需要对其进行pthread_join 操作，否则无法释放资源，从而造成系统泄漏

如下是主线程等待新线程

void* newthread(void* args)
{
    int cnt = 5;
    while(cnt)
    {
        cout << "I am new thread" << endl;
        sleep(1);
        cnt--;
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthread, nullptr);

    cout << "thread wait block" << endl;
    pthread_join(tid, nullptr);
    cout << "thread wait return" << endl;
    return 0;
}

在这里插入图片描述

如果不要等待，必须对新线程进行分离（可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离）

接口：
在这里插入图片描述
分离的线程不需要等待，主线程可以做自己的事情

void* newthread(void* args)
{
    int cnt = 5;
    while(cnt)
    {
        cout << "I am new thread" << endl;
        sleep(1);
        cnt--;
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthread, nullptr);
    //分离新线程
    pthread_detach(tid);
    while(true)
    {
        cout << "I am main thread" << endl;
        sleep(1);
    }

    // cout << "thread wait block" << endl;
    // pthread_join(tid, nullptr);
    // cout << "thread wait return" << endl;
    return 0;
}

在这里插入图片描述

如果让主线程5秒结束，分离的线程死循环：

void* newthread(void* args)
{
    while(true)
    {
        cout << "I am new thread" << endl;
        sleep(1);
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthread, nullptr);
    //分离新线程
    pthread_detach(tid);
    int cnt = 5;
    while(cnt--)
    {
        cout << "I am main thread" << endl;
        sleep(1);
    }
    return 0;
}

在这里插入图片描述
线程分离了，但是资源依然是共享的，主线程先退出，那么整个进程就会结束，分离的线程也同样退出。

如果分离的线程中的某个函数有异常（比如除0错误），整个进程会直接退出，并打印报错信息

void* newthread(void* args)
{
    while(true)
    {
        cout << "I am new thread" << endl;
        sleep(1);
        int a = 10;
        a /= 0;
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, newthread, nullptr);
    //分离新线程
    pthread_detach(tid);
    while(true)
    {
        cout << "I am new thread" << endl;
        sleep(1);
    }
    return 0;
}

在这里插入图片描述

～yY…s<#>
关注
  • 22
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
linux系统线程通信的几种方式,Linux进程间通信-线程间通信
weixin_31663397的博客
04-28 4386
Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信方法：管道、消息队列、共享内存、信号量、套接口。1、管道管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。2、 消息队列消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，是一个在系统内核中用来保存消息的队列，它在系统内核中是以...
Linux操作系统基础知识
chenyfan_blog
06-02 8500
Linux操作系统基础知识
怎么查看linux系统总线程,Linux系统如何查看进程的线程数
weixin_32643811的博客
04-28 2113
Linux系统如何查看进程的线程数导读：小编根据大家的需要整理了一份关于《Linux系统如何查看进程的线程数》的内容，具体内容：Linux系统的进程是由线程组成的，当然Linux进程下的线程数是不固定的，可以是一个进程，也可以是...Linux系统的进程是由线程组成的，当然Linux进程下的线程数是不固定的，可以是一个进程，也可以是多个进程。本文就来教大家？一、使用命令查看Linux进程的’线程数...
Linux多线程
weixin_58867976的博客
09-26 2738
Linux多线程详解
Linux线程调度策略与优先级
dinghuiyang的博客
12-14 2957
Linux线程调度策略与优先级
Linux 操作系统&线程2
jcf5832的博客
05-07 1350
线程
Linux 操作系统下的指纹开发
Winuim纹宁信息的博客
03-08 6239
Linux，全称GNU/Linux，是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX的多用户、多任务、支持多线程和多CPU的操作系统。伴随着互联网的发展，Linux得到了来自全世界软件爱好者、组织、公司的支持。它除了在服务器方面保持着强劲的发展势头以外，在个人电脑、嵌入式系统上都有着长足的进步。使用者不仅可以直观地获取该操作系统的实现机制，而且可以根据自身的需要来修改完善Linux，使其最大化地适应用户的需要。 随着互联网和物联网应用的普及，现在已经有越来越多的智能设备集成了指纹识别模块，
Linux操作系统基础原理
weixin_42967944的博客
12-10 7226
操作系统基础原理 计算机自身是由众多电子元器件构成，硬件本身提供给用户的接口十分底层复杂，使用很不方便。在硬件之上的操作系统将硬件接口抽象封装为比较直观，用户容易调用的接口；用户开发应用程序，通过指令代码调用这些接口完成任务。 狭义的操作系统主要指系统内核，内核有以下作用：进程管理、文件系统、网络管理、内存管理、驱动程序、安全功能。内核可以将用户无法操作的底层硬件接口进行抽象并封装为用户可以操作...
操作系统实验二 进程（线程）同步
weixin_61814212的博客
05-14 5723
实验二相比实验一难度有所提升，首先得先掌握好相应的理论知识（读者-写者问题和消费者-生产者问题），才能在实验中得心应手。任务二的代码编写可以借鉴源码，所以我们要先读懂源码。
linux 操作系统 多线程编程 经典同步算法--读者写者问题
07-06
因此要求：①允许多个读者可以同时对文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。
操作系统上机-Linux多线程编程
05-18
在操作系统的学习过程中，掌握Linux多线程编程是至关重要的技能之一。Linux作为一款广泛使用的开源操作系统，其强大的系统调用接口和丰富的库函数为开发者提供了实现多线程应用的便利条件。多线程编程允许程序同时...
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
头哥实践平台操作系统实验-实训一 linux 进程和线程1-2关
07-05
头哥操作系统实验学习参考代码
Linux操作系统教程
07-01
本篇文章将为大家介绍一些关于Linux操作系统教程的基本知识。 LINUX操作系统基础概念 Linux操作系统由内核和外壳组成。内核是操作系统的核心，负责控制计算机的硬件和资源。Shell是与用户交互的外部程序，它提供了...
【Linux】：信号与信号产生
最新发布
Yikefore的博客
09-12 624
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
Linux 进程控制
2302_77289177的博客
09-08 1216
Linux 进程控制
掌握 Linux 命令的艺术：深入解析与实用指南
hacker__的博客
09-06 1440
Linux操作系统是和windows操作系统是并列的关系。只不过只是两个操作系统的特性各有不同而已。
高效诊断Linux性能问题
Tiger93的博客
09-08 520
诊断Linux性能问题
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值