Linux从0到1——初识线程【什么是线程/线程控制/详解tid】

已于 2024-12-16 23:14:30 修改
阅读量1.1k 收藏 10
点赞数 17
分类专栏： Linux 文章标签： linux java android
于 2024-12-16 23:10:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_73870552/article/details/142282308
版权

Linux从0到1——初识线程

1. 什么是线程？

1.1 线程的概念

1. 线程概念

  • 课本上的概念：
    • 线程是比进程更加轻量化的一种执行流；
    • 线程是在进程内部执行的一种执行流。
  • 我们的理解：
    • 线程是CPU调度的基本单位；
    • 进程是承担系统资源的基本实体。

2. 理解线程

在这里插入图片描述

  • 每创建一个进程，就需要创建对应的地址空间mm_struct，PCB，页表。开销实际上是比较大的。那么可不可以设计一种更轻量级的进程？让这种轻量级进程，和主进程共用一个地址空间，共用一个页表？
  • 上面的方案从技术上来说一定是可行的，我们只需要另外为这个轻量级进程创建一个PCB，然后将主进程的地址空间划分出一块给这个新进程即可。我们将这种轻量级进程，叫做“线程”。
  • “线程”只参与资源的分配，而不参与资源的创建。

3. 线程的管理（Linux）

  • OS中如果要支持线程，也就必须要对它进行管理，即先描述，再组织。那是不是意味着，需要再设计一个TCB即线程控制块，来描述它？以及再设计一套线程的调度方法？这样是不是有点太复杂了。
  • 实际上，PCB中已经包含了一个执行流需要的所有信息，而且基于PCB的调度算法也是十分完备的。所以线程只需要复用PCB，和PCB的调度方法即可。

4. Linux中线程的实现方案

  • 很多操作系统的书籍中，只是告诉你一个操作系统中应该有什么，而不会告诉你具体怎么实现。所以，操作系统更像是一种指导文档，告诉我们一个线程应该有什么样的特点，而不会告诉我们具体怎么实现。
  • 我们上面谈的线程管理，只是Linux中对线程的管理方案。线程复用PCB。
  • 从CPU的角度来看，如何区分这个PCB是线程还是进程？答案是不需要区分，CPU的任务只是调度执行流，不关心是进程还是线程。就好比一个快递员的主要任务是发送快递，而不关心快递包装中具体装的是什么。
  • Linux中不存在严格意义上的线程，CPU在调度时，将每一个PCB都看作是一个“轻量级进程（Light Weight Process）”，线程只是对用户层的一个封装。CPU中的基本调度单位是轻量级进程LWP。

5. 如何看待之前学习的进程，和今天所学的进程？

  • 之前所学的进程，是内部只有一个执行流的进程；
  • 今天学习的是内核中有多个执行流的进程。

6. 从CPU调度的角度，理解线程的轻量化

  • 之前我们只是提到了，线程的创建更加轻量化，只需要创建对应的PCB即可。
  • 就CPU调度而言，切换进程，需要切换CPU中大量的寄存器信息，包括页表的，地址空间的等等。但是对于线程，只需要切换一些临时寄存器中的信息即可。
  • 上面提到的仍然不是线程切换解决的主要矛盾，线程切换真正的优势和CPU中的一个硬件cache有关：
    • 根据局部性原理，访问某一行代码时，下一次有较大概率访问这段代码前后一部分的代码。比如现在程序运行到了main函数的第10行，那么极有可能下一次运行的就是0到20行中的其中一段代码。科学家们根据这一原理设计出了cache，它的作用是将一段代码的前后多行代码加载进CPU，下一次访问时先在cache中查找有没有要执行的代码，如果没有再去内存中找，提高了效率。我们将cache中的数据叫作热数据。
    • 进程在切换时，需要重新对cache中的数据做热加载，即刷新cache。而线程切换则不需要刷新cache。这就是线程最主要的优势。

7. 进程时间片也要被内部的线程瓜分，时间片也是资源

  • 如果OS会为每一个线程也分配时间片，这就是一个严重的bug。用户可以通过不断创建线程，来抢占CPU资源，获得优先调度权。

1.2 结合代码理解线程

1. pthread_create函数

在这里插入图片描述

  • 可以看到该接口在3号手册中，所以这不是一个系统接口，而是库函数。
  • 参数：
    • pthread_t *thread：输出型参数，返回线程标识符；
    • const pthread_attr_t *attr：指向线程属性对象，定义了线程的属性，如果不需要特殊属性可以传入 NULL。
    • void *(*start_routine) (void *)：线程启动时执行的函数，它必须返回一个 void* 类型的值，并且接受一个 void* 类型的参数。
    • void *arg：传递给 start_routine 函数的参数。

这里了解一下即可，之后还会细讲。

2. 实验代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>

void *ThreadRoutine(void *args)
{
    usleep(1000);   // 让主线程先打印
    const char *threadname = (const char *)args;
    while(true)
    {
        std::cout << "I am a new thread：" << threadname << ", pid:" << getpid() << std::endl;
        sleep(1); 
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, (void*)"thread 1");   // 创建线程

    // 主线程
    while(true)
    {
        std::cout << "I am main thread" << ", pid: " << getpid() << std::endl;
        sleep(1);
    }
    return 0;
}
  • 由于<pthread.h>线程库是第三方库，所以编译时要带上选项-lpthread。

3. 实验现象

  • ps -aL命令会列出所有终端的进程，并且对于每个多线程的进程，它会显示该进程下所有线程的详细信息。

在这里插入图片描述

  • 上图中显示的LWP这一列对应的数据是轻量级进程id，可以看到，两个线程的PID相同，属于同一进程，并且主线程的PID和LWP相同。

1.3 重谈地址空间

1. 页帧和页框

在这里插入图片描述

  • 文件系统IO的基本单位大小为4KB，这个大小又叫Page size。因为有这个规则的存在，所以从逻辑上将文件hello.exe划分成一块一块的4kb空间，每一块叫做一个页帧。
  • 将磁盘文件换入到内存时，也是按4kb的大小换入的，为了适配页帧，物理内存也划分出了一个一个4kb大小的页框。
  • 有了页框，OS还需要知道每个页框的使用情况，有没有被占用，是否异常等各种信息。先描述，再组织。
struct page
{
	// 描述一个页框的使用情况
	// page的属性
	int flag;
	...
}
  • 有了描述页框的结构体，还需要将他们管理起来，使用了数组struct page pages[1048576]，所以，对内存的管理，就变成了对数组内容的增删查改。

2. 重谈页表

在这里插入图片描述

  • 假设现在是32位机器，那么虚拟地址就有232个。如果按照我们之前理解的页表，一个虚拟地址对应一个物理地址，假设页表中一行有8byte（当前不止8byte，只是假设），那么一个页表的大小就有4GBX8byte，这远远超出了内存的承受范围。所以之前的理解是片面的，是不正确不严谨的。

在这里插入图片描述

  • 真实的页表结构如上图所示。32位机器的虚拟地址有32位，前10位是一个数组下标，通过该下标可以在页目录中找到下一级的页表。中间10位也是数组下标，通过该下标可以找到物理内存中的页框起始地址。最后12位则是偏移量，通过这样一套页框起始地址+偏移量的方式，就可以精准定位到物理内存中的每一个字节了。
  • 为什么偏移量有12位？因为一个页框的大小是4KB，正好就是212字节。这样一来，页表最大也就只有220x4byte，远远小于之前的232x8byte。
  • 并且页表是动态开辟的，一个页表用完了，就再开辟一个，这就又缩小了页表的大小。

3. 划分进程的本质

  • 划分进程资源的本质，就是划分页表。划分页表的本质，是划分地址空间。

1.4 线程的优缺点

1. 线程的优点

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

2. 线程的缺点

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

2. 线程异常和线程用途

1. 线程异常

  • 单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃；
  • 线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出。

2. 线程用途

  • 合理的使用多线程，能提高CPU密集型程序的执行效率；
  • 合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）。

3. Linux进程VS线程

1. 进程VS线程

  • 进程是资源分配的基本单位；
  • 线程是调度的基本单位。

2. 线程共享进程数据，但也拥有自己的一部分数据

  • 线程ID；
  • 一组寄存器，独立的硬件上下文数据；
  • 独立的栈结构；
  • errno；
  • 信号屏蔽字；
  • 调度优先级。

3. 进程的多个线程共享同一地址空间，因此数据段、代码段都是共享的。如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到，除此之外，各线程还共享以下进程资源和环境：

  • 文件描述符表；
  • 每种信号的处理方式（SIG_ IGN、SIG_ DFL或者自定义的信号处理函数）；
  • 当前工作目录；
  • 用户id和组id。

4. 进程和线程关系图

在这里插入图片描述

4. 详解pthread_create的arg参数

4.1 给线程传参

通过该函数的arg参数给线程传参。arg是void*类型的参数，这就说明我们可以传任意类型的参数。以下是一个传参的示例，使用了一个自定义类型描述线程的相关信息。

#include <iostream>
#include <string>
#include <functional>
#include <time.h>
#include <unistd.h>
#include <pthread.h>

// typedef std::function<void()> func_t; 下面的写法和这句代码等价
using func_t = std::function<void()>;   // C++11新语法

// 线程的相关数据
class ThreadData
{
public:
    ThreadData(const std::string &name, const uint64_t &ctime, func_t f)
        :threadname(name), createtime(ctime), func(f)
    {}

public:
    std::string threadname; // 线程名
    uint64_t createtime;    // 线程创建时间
    func_t func;            // 该线程执行的方法
};

void Print()
{
    std::cout << "我是线程执行的大任务的一部分" << std::endl;
}

// 新线程
void *ThreadRountine(void *args)
{
    ThreadData *td = static_cast<ThreadData*>(args);
    while(true)
    {
        std::cout << "new thread" << std::endl;
        std::cout << "thread name: " << td->threadname << std::endl;
        std::cout << "create time: " << td->createtime << std::endl;
        td->func();
        sleep(3);
    }
}

// 主线程
int main()
{
    pthread_t tid;
    ThreadData *td = new ThreadData("thread 1", (uint64_t)(time(nullptr)), Print);
    // 传参直接传td
    pthread_create(&tid, nullptr, ThreadRountine, td);

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

在这里插入图片描述

4.2 一次创建多个线程

#include <iostream>
#include <string>
#include <functional>
#include <vector>
#include <time.h>
#include <unistd.h>
#include <pthread.h>

// typedef std::function<void()> func_t; 下面的写法和这句代码等价
using func_t = std::function<void()>;

#define threadnum 5

class ThreadData
{
public:
    ThreadData(const std::string &name, const uint64_t &ctime, func_t f)
        :threadname(name), createtime(ctime), func(f)
    {}

public:
    std::string threadname;
    uint64_t createtime;
    func_t func;
};

// 新线程
void *ThreadRountine(void *args)
{
    ThreadData *td = static_cast<ThreadData*>(args);
    while(true)
    {
        std::cout << "new thread." 
                  << " thread name: " << td->threadname 
                  << " create time: " << td->createtime 
                  << std::endl;
        sleep(1);
    }
}

int main()
{
    std::vector<pthread_t> pthreads;    // 存储线程的tid
    for (size_t i = 0; i < threadnum; i++)
    {
        char threadname[64];
        snprintf(threadname, sizeof(threadname), "%s-%lu", "thread", i);

        pthread_t tid;
        ThreadData *td = new ThreadData(threadname, (uint64_t)(time(nullptr)), nullptr);
        pthread_create(&tid, nullptr, ThreadRountine, td);
        pthreads.push_back(tid);
        sleep(1);       // 隔一秒创建一个线程
    }

    while(true)
    {
        sleep(1);
    }
    
    return 0;
}

在这里插入图片描述

5. 线程控制

5.1 线程退出

1. 线程退出的两种方式

  • 直接return；
  • 使用pthread_exit()函数;
    • 该函数的retval参数，就是线程想返回给主进程的内容。

在这里插入图片描述

2. 主线程如何获得新线程的退出信息？

  • pthread_join()函数可以等待线程退出，类似于进程等待。线程退出，没有等待，会导致类似进程的僵尸问题。
  • 其中thread参数指的是要等待的线程id，retval参数则是用来接收新线程的返回值。

在这里插入图片描述

  • 返回值：等待成功返回0；不成功返回错误码errno。

3. 以下是一个完成的线程等待+获取退出信息示例

#include <iostream>
#include <string>
#include <functional>
#include <time.h>
#include <unistd.h>
#include <pthread.h>

class ThreadReturn
{
public:
    ThreadReturn(pthread_t id, const std::string &info, int code)
        :_id(id), _info(info), _code(code)
    {}
public:
    pthread_t _id;      // 线程id
    std::string _info;  // 退出信息
    int _code;          // 退出码
};

void *threadRoutine(void *arg)
{
    std::string name = static_cast<const char*>(arg);
    int cnt = 5;
    while(cnt--)
    {
        std::cout << "new thread is running, thread name: " << name 
                  << " tid: " << pthread_self() << std::endl;   // pthread_self函数返回线程自己的id
        sleep(1);
    }

    ThreadReturn *ret = new ThreadReturn(pthread_self(), "thread quit normal", 10);
    // 以下两种线程退出方式任选其一
    // 1. return ret;         
    // 2. pthread_exit(ret);

    // 这里选第一种
    return ret;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"thread-1");

    // 线程默认要被等待！
    //  1. 线程退出，没有等待，会导致类似进程的僵尸问题
    //  2. 线程退出时，主线程如何获取新线程的返回值？
    void *ret = nullptr;
    int n = pthread_join(tid, &ret);
    ThreadReturn *r = static_cast<ThreadReturn*>(ret);

    std::cout << "main thread get new thread return: " << r->_id 
            << ", " << r->_info
            << ", " << r->_code
            << std::endl;
    
    std::cout << "main thread done. n: " << n << std::endl;
    
    return 0;
}

在这里插入图片描述

5.2 线程分离

1. 线程分离的使用场景

  • 在多线程场景中，如果主线程pthread_join了某一个新线程，且该新线程未退出，则主线程会发生阻塞等待。如果我们不希望主线程阻塞等待该新线程，可以将该新线程设置为分离状态。分离状态下的新线程，退出后会被自动回收，不需要主线程进行等待。
  • 当主线程不关心新线程任务的完成情况时，就可以使用线程分离。

2. 设置线程分离的两种方式

在这里插入图片描述

  • 直接在新线程的任务块中，调用pthread_detach方法：
// 新线程任务块
void *threadRoutine(void *arg)
{
    // 线程分离
    pthread_detach(pthread_self());

    ...
}

// 主线程
int main()
{
	...
}
  • 在主线程中，调用pthread_detach：
// 新线程
void *threadRoutine(void *arg)
{
    ...
}

// 主线程
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"thread-1");
    // 线程分离
    pthread_detach(tid);
    ...
}

如果新线程被设置分离了，主线程还pthread_join它，错误码被设置，返回22。

5.3 线程取消

1. pthread_cancel函数

在这里插入图片描述

  • 功能是取消一个执行中的线程。
  • 参数thread是线程id。
  • 执行成功返回0，失败返回错误码。

2. 代码示例

#include <iostream>
#include <string>
#include <functional>
#include <time.h>
#include <unistd.h>
#include <pthread.h>

void *threadRoutine(void *arg)
{
    std::string name = static_cast<const char*>(arg);
    while(1)
    {
        std::cout << "new thread is running, thread name: " << name 
                  << " tid: " << pthread_self() << std::endl;   // pthread_self函数返回线程自己的id
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"thread-1");

    // 3秒后取消新线程
    sleep(3);
    pthread_cancel(tid);

	// 等待新线程
    void *ret = nullptr;
    int n = pthread_join(tid, &ret);
    std::cout << "main thread done. n: " << n << " ret: " << (int64_t)ret << std::endl;

    return 0;
}

在这里插入图片描述

  • 这里新线程被主线程取消了，虽然新线程没有执行自己的return退出语句，但是主线程也拿到了ret返回值，是-1。被取消的线程的返回值，默认都是-1。

分离状态的线程也可以被取消，分离和取消不冲突，但是和等待pthread_join冲突。

6. 详解线程id

1. 问题引入

#include <iostream>
#include <string>
#include <functional>
#include <time.h>
#include <unistd.h>
#include <pthread.h>

void *threadRoutine(void *arg)
{
    std::string name = static_cast<const char*>(arg);
    while(1)
    {
        std::cout << "new thread is running, thread name: " << name 
                  << " tid: " << pthread_self() << std::endl;   // pthread_self函数返回线程自己的id
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"thread-1");
    while(true)
    {
        std::cout << "main thread, sub thread: " << tid << std::endl;
        sleep(1);
    }

    return 0;
}

在这里插入图片描述

  • 为什么LWP，即轻量级进程id，和线程的tid不同？线程id到底是什么？

2. pthread共享库

  • Linux没有真正的线程，只有轻量级进程的概念，所以Linux OS只会提供轻量级进程创建的系统调用，不会直接提供线程创建的接口。
  • 但是我们学习操作系统时，一直接触的就是线程，难道为了学Linux，还要再花功夫专门学一下轻量级进程吗？这显示是不合理的，所以Linux的解决方案是，在用户层和系统层之间，加入了一层软件层，封装了轻量级进程的调用接口，对上直接提供线程的控制接口。
  • 这层中间的软件层，就是pthread原生线程库。

在这里插入图片描述

Linux为什么不直接在系统层设计线程，还非要搞一个轻量级进程，最后还必须用一个库来封装成线程？

  • 首先，直接在系统层设计线程，技术上是绝对可以实现的。Linux之所以没有采取这种方式，是因为它觉得轻量级进程，是自己系统的一大特色，而不是缺点。其中一个特色就是，轻量级进程复用PCB，调度方法也复用进程的调度方法。
  • 一个完整的Linux系统，默认是携带pthread原生线程库的，如果没有，那么这个Linux系统是残缺的。

3. 线程管理

  • 我们之前所使用的线程控制接口，全部都不是系统接口，而是原生线程库pthread提供的接口。
  • 既然可以同时存在多个线程，那么肯定也需要对线程进行管理（先描述，再组织），在Linux中，这个管理工作是交给pthread库来执行的（先提出这个概念，一步步慢慢理解）。
  • 线程要有自己独立的硬件上下文和独立的栈结构，默认地址空间中的栈，由主线程使用。
  • 事实上，Linux系统也提供了直接创建轻量级进程的接口：
    • child_stack参数允许用户显示的传栈地址，也就是指定分配的栈地址空间。

在这里插入图片描述

  • pthread_create底层封装的就是这个接口，也会自动帮我们分配该轻量级进程的栈地址空间。pthread库中会有专门的结构化数据struct tcb，将轻量级进程封装为线程，来存储每个LWP的相关信息，包括该LWP所占用的栈空间地址。tcb需要和LWP一一对应，所以也要存储该LWP对应的轻量级进程id。
  • pthread作为共享库，一次加载后，被所有进程所共享，所以各个进程可以看到多个用户启动的所有线程。

4. tid

在这里插入图片描述

  • 每创建一个线程，pthread中就会记录一个线程属性集合，包括struct pthread，线程局部存储，线程栈。这个线程属性集合，就可以理解成是tcb。
  • 所谓tid，线程id，实际上就是各个属性集合的地址，所以tid的本质是一个地址。
  • 这个属性集合中，还存有类似void *ret的数据，用来保存线程的返回值。这个返回值可以通过pthread_join方法获取。所以线程的返回值并不是存储在系统中的，而是存储在库中的。

5. 站在语言角度，理解pthread

  • C++11的多线程，本质上，就是对原生线程库的封装。
#include <iostream>
#include <thread>

// 这是一个简单的函数，将作为线程执行的任务
void print_numbers(int n) {
    for (int i = 0; i < n; ++i) {
        std::cout << "Number: " << i << std::endl;
    }
}

int main() {
    std::cout << "Main thread starting." << std::endl;

    // 创建一个线程，传递函数print_numbers和它的参数
    std::thread t(print_numbers, 10); // 这里的10是print_numbers函数的参数

    // 在主线程中做一些事情
    std::cout << "Main thread doing other work." << std::endl;

    // 等待线程t完成
    t.join();

    std::cout << "Main thread finished." << std::endl;

    return 0;
}
  • 上面这部分代码，在Linux上跑，就会去调用Linux的原生线程库。在Windows上跑，就会调用Windows的原生线程库。同样的代码可以跑在不同的操作系统上，这就是语言层面的可移植性。

6. 线程的局部存储

  • 全局变量本身是被所有线程所共享的，这不难理解。全局变量存储在数据段，而所有线程共享一个地址空间。
  • 给全局变量前面加上__thread修饰（这实际上是一个编译选项），每个线程就会在自己的tcb中，多开辟一块空间，存储这个变量。这样每个线程实际上就拥有了自己独立的全局变量。这就是线程的局部存储。
[网络安全自学篇] 八十五.《Windows黑客编程技术详解》之注入技术详解（全局钩子、远线程钩子、突破Session 0注入、APC注入）
杨秀璋的专栏
06-25 2万+
从这篇文章开始，作者将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充知识点，希望对您有所帮助。第二篇文章主要介绍4种常见的注入技术，包括全局钩子、远线程钩子、突破SESSION 0隔离的远线程注入、APC注入，案例包括键盘钩子、计算器远线程注入实现、APC注入等，希望对您有所帮助。
【专栏必读】王道考研408操作系统+Linux系统编程万字笔记、题目题型总结、注意事项、目录导航和思维导图
热门推荐
快乐江湖的博客
10-27 3万+
王道408考研操作系统)第一章计算机系统概述-第一节1、2：操作系统概念、概念和特征1：理解fork的作用prinf("还没有执行fork函数的本进程为：%d\n" , getpid());//其返回值是pid类型的 sleep(1);if(ret > 0) //父进程返回的是子进程ID {printf("我是父进程，我的id是：%d,我的孩子id是%d\n" , getpid() , ret);sleep(1);} } else if(ret == 0) //子进程fork返回值是0 {.........
【Linux修行路】初识线程——线程控制
m0_68662723的博客
09-03 1248
线程是进程内的一个执行分支，线程的执行粒度，要比进程细。
【linux线程(4)】初识线程池&手撕线程池
2301_77900444的博客
01-21 590
线程池在校招面试阶段经常被要求手撕,可见它的重要性如何.本章重点:本篇文章会先介绍什么是池化技术,然后详细讲解什么是线程池,以及如何手撕线程池,并且会给大家拓展如何将线程池设计为单例模式,以及读写锁的使用方法,最后会讲解如何在校招中遇见手撕线程池时,快速的写出代码.大家可能听说过线程池,进程池,对象池,甚至是内存池等概念,那么到底什么是池?它们有什么共同特质?池化技术:池化技术指的是提前准备一些资源，在需要时可以重复使用这些预先准备的资源 .
【Linux从0到1】第十三篇：网络编程套接字
Pass-by
07-16 1803
本节只介绍基于IPv4的socket网络编程,sockaddr_in中的成员structin_addrsin_addr表示32位的IP地址但是我们通常用点分十进制的字符串表示IP地址,以下函数可以在字符串表示和in_addr表示之间转换;们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分,磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分,网络数据流同样有大端小端之分.那么如何定义网络数据流的地址呢?此处我们的端口号也是唯一表示一个进程.那么这两者之间是怎样的关系?...
【多线程】C/C++语言中多线程和简单例子
小鱼菜鸟的博客
10-04 390
目录 前言 一、pthread两种状态joinable和unjoinable 二、thread.join() 方法存在的必要性 三、为什么要多线程： 问题： 简单的多线程编程 线程的数据处理 四、实例代码 C++ Codewindows C++ linux Code 线程C++11 更简便，推荐学习C++11的多线程： ...
Linux 线程互斥
cp
09-28 943
介绍Linux的线程互斥、以及互斥量接口的使用
线程基础知识点
work_hard423的博客
02-23 881
1
Linux——线程详解（一）
cxy_zjt的博客
09-07 897
初识线程 1.inux下的线程 2.再谈进程 3.理解页表 4. 再次理解虚拟到物理的转化 线程的控制 1.线程的创建 2.线程异常 3.验证`pthread_join` 的第二个参数 4.线程的退出方式 5. 线程的公有和私有 6.pthread_t 与线程独立栈 7.线程的局部性存储 8.线程分离
详解Java线程安全
weixin_34060299的博客
04-09 166
一、内存模型 高速缓存 因为CPU执行速度和内存数据读写速度差距很大，因此CPU往往包含高速缓存结构。 当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。 缓存不一致问题 执行下面的代码： int i = 0; i = i + 1; 复制代码当线程执...
初识网络及socket编程基础
aaaaaaaWoLan的博客
02-04 2279
国产精品ORM框架-SqlSugar详解 进阶功能 集成整合 脚手架应用 附源码 云草桑 专题二
cao919的专栏Net
07-13 1088
进阶功能　　4.1、生命周期　　4.2、执行Sql　　4.3数据导入和更新+验证　　4.4、并发控制、更新、版本控制　　4.5、悲观锁--数据库中支持的锁　　4.6、事务　　4.7、打包提交　　4.8、AOP日志、拦截　　4.9、二级缓存　　4.10、支持读写分离　　4.11、数据库分表　　　4.11.1垂直分表　　　4.11.1水平分表　　　4.11.2SqlSugar自动分表　　　4.11.3SqlSugar自定义规则分表　　4.12、Saas分库--多租户分库　　　4.12.1、SqlSugarSco
【Windows系统CUDA安装终极指南】：从Win7到Win10，全方位解决安装CUDA8.0的疑难杂症
[【Windows系统CUDA安装终极指南】：从Win7到Win10，全方位解决安装CUDA8.0的疑难杂症](https://img-blog.csdnimg.cn/direct/62919f166e5e442f8161a3aff804c058.jpeg) # 摘要 CUDA是一种由NVIDIA推出的并行计算平台...
在 Linux 中，目录权限，mkdir -m 选项，用法
jie18894575860的博客
05-28 453
在 Linux 中，mkdir -m 选项用于在创建目录时直接指定权限模式（无需依赖默认的 umask）。默认权限：若省略 -m，目录权限由 umask 决定（通常 777 -umask）。执行权限（x）：目录需要执行权限才能进入（cd）或访问其内容。安全建议：避免随意使用 777，可能引发安全风险。第三位：其他用户（Others）权限。第一位：所有者（Owner）权限。第二位：所属组（Group）权限。八进制 符号表示 权限说明。使用 u（所有者）、
Rock9.x（Linux）安装Redis7
最新发布
{竹子}
05-31 395
设置后台运行：将daemonize no改为daemonize yes。gcc 是C语言编译器，Redis是用C语言开发的，我们需要编译它。如果没有安装gcc，那么我们手动安装。在解压目录运行命令，必须写sudo。创建存放配置文件的文件夹。解压，进入解压文件夹。
Linux | Shell脚本的基础知识
2302_81507127的博客
05-29 784
执行一条命令完毕后，系统会给出一个退出值，若成功则为0，出现错误则1~255退出状态码是一个整数，其有效范围为0~255行为良好的UNIX命令，程序和工具都会返回0作为退出码来表示成功。
Linux之文件&进程间通信&信号
Steve__evetS的博客
05-30 876
Linux之文件&进程间通信&信号 文件 文件描述符 文件操作 重定向 缓冲区 一切皆文件的理解 文件系统 磁盘物理结构&块 文件系统结构 软硬链接 进程间通信 匿名管道 命名管道 system V共享内存 信号
Linux远程数据同步——rsync命令详解
想进步的职场菜鸟。
05-30 681
rsync是强大的远程数据同步工具，采用差异算法提升传输效率。本文详解参数用法，提供本地/远程同步示例，涵盖权限保留、进度显示等核心功能。
使用 Kali Linux 入侵 Metasploitable 2 虚拟机
sgafdgdagd的博客
05-28 583
Metasploitable 2 是一台故意设计成不安全的虚拟机，旨在帮助渗透测试人员入门黑客世界。这台机器充满了安全漏洞和过时/未打补丁的软件。
Linux文件管理
ZZH1120KQ的博客
05-29 1445
Vim 是从 vi 发展出来的一个文本编辑器。代码补全、编译及错误跳转等方便编程的功能特别丰富，在程序员中被广泛使用。vi 是老式的字处理器，不过功能已经很齐全了，但是还是有可以进步的地方。vim则可以说是程序开发者的一项很好用的工具。此外还有nano编辑器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-指短琴长-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值