Linux 第三十三章

🐶博主主页：@ᰔᩚ. 一怀明月ꦿ

❤️‍🔥专栏系列：线性代数，C初学者入门训练，题解C，C的使用文章，「初学」C++，linux

🔥座右铭：“不要等到什么都没有了，才下定决心去做”

🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀

线程

线程控制

pthread_create创建线程

pthread_self

pthread_join

Pthread_exit

pthread_detach

pthread_cancel

系统库调用问题

线程的局部存储

线程

重谈一次地址空间-虚拟到物理的过程

文件系统IO的基本单位大小：4kb

内存以4GB为例，就有1048576个页框（4kb）

struct page

{

    int flag;//用于表示该页的状态和属性

    //描述一个page的使用情况

    //页框的属性

}

为了对所有的页框进行管理，所以需要一个struct page pages[1048576]的数组

线程划分页表的本质:划分地址空间

Int a=100

根据a的虚拟地址，找到a的物理地址，a是一个整形变量，偏移量就位4

在进程视角：虚拟地址本身就是资源！

线程共享进程数据，但也拥有自己的一部分数据:
线程ID
一组寄存器（每个线程有自己的独立上下文数据）
栈
errno
信号屏蔽字
调度优先级

线程控制

pthread_create创建线程
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);
这个函数的参数包括：

* thread：指向 pthread_t 类型的指针，用于存储新创建线程的标识符。
* attr：指向 pthread_attr_t 类型的指针，用于设置新线程的属性，通常可以设为 NULL 表示使用默认属性。
* start_routine：指向一个函数的指针，该函数定义了新线程要执行的任务。它的签名为 void* func(void*)。
* arg：传递给 start_routine 函数的参数。//对象/结构体
linux下有没有真正的线程？

没有。只有轻量级进程的概念，所以linux os只会提供轻量级进程创建的系统调用，不会直接提供线程创建接口

所以需要一个库pthread，这个库不属于c/c++，这个库是操作系统自带的，编译时链接我们的库

function<void()> 是 C++11 中引入的函数对象，它可以用来表示一个没有参数且没有返回值的函数。在 C++ 中，函数对象是可调用的实体，类似于函数指针，但具有更大的灵活性和功能。

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

using namespace std;

const int threadnum = 5;
using func_t = function<void()>;

class threaddata
{
public:
threaddata(const string &name, const uint64_t &time, func_t f)

: threadname(name), createtime(time), func(f)

{
}


public:
string threadname;

uint64_t createtime;

func_t func;

};


void print()

{
cout << "我是线程执行的大任务的一部分" << endl;

}


// 新线程
void *ThreadRountine(void *args)

{
threaddata *td = static_cast<threaddata *>(args); // 安全强转threaddata*类型

while (true)

{
cout << "new thread"

<< " thread name:" << td->threadname << " thread time:" << td->createtime << endl;

td->func();
sleep(1);


//测试一个线程异常，整个进程就结束了
// int a=10;
// if(td->threadname=="thread-4")
// {
// cout<<"触发异常"<<endl;
// a/=0;
// }
}
}


// 如何给新线程传参，如何创建多线程呢
// 获取返回值


// 主线程
int main()

{
vector<pthread_t> pthreads;

for (int i = 0; i < threadnum; i++)

{
char pthreadname[64];

snprintf(pthreadname, sizeof(pthreadname), "%s-%lu", "thread", i);

pthread_t tid;

threaddata *td = new threaddata(pthreadname, (uint64_t)time(nullptr), print);

pthread_create(&tid, nullptr, ThreadRountine, td);

pthreads.push_back(tid);
sleep(1);
}


while (true)

{
cout << "main thread" << endl;

sleep(3);
}
return 0;

}
pthread_self

在Linux中，pthread_self 函数用于获取当前线程的线程ID（pthread_t）。

它的声明如下：
#include <pthread.h>
 pthread_t pthread_self(void);
调用 pthread_self 函数将返回当前线程的线程ID，即 pthread_t 类型的值。线程ID 是一个唯一标识符，用于区分不同的线程。通常情况下，你可以将线程ID存储在变量中以供后续使用。

线程终止

1. 新线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。

2. 线程可以调用pthread_exit终止自己。

3. 一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

线程默认要被等待

1.线程退出，没有等待，会导致类似进程的僵尸问题

2.线程退出时，主线程如何获取新线程的返回值！

pthread_join

pthread_join 是 POSIX 线程库中的函数，用于等待指定的线程结束执行。它会阻塞当前线程，直到指定的线程完成为止。
int pthread_join(pthread_t thread, void **retval);
* thread：要等待的线程的线程 ID。
* retval：指向指针的指针，用于接收被等待线程的返回值（如果有）。
事例
#include <stdio.h>
#include <pthread.h>
void* threadFunction(void* arg) {
    printf("Inside the new thread\n");
    return (void*)42;
}
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, threadFunction, NULL); // 创建一个新线程
    // 等待新线程结束
    void* result;
    pthread_join(thread, &result);
    printf("New thread returned: %ld\n", (long)result);
    return 0;
}
在这个示例中，我们创建了一个新线程，并在主线程中调用 
pthread_join 来等待新线程结束。pthread_join 函数会将主线程阻塞直到新线程执行结束，
并且可以获取新线程的返回值。
需要注意的是，pthread_join 函数会阻塞当前线程，直到指定的线程结束。因此，在实际使用中，需要确保调用 pthread_join 的线程不是主要的执行线程，否则可能会导致整个程序被阻塞。

Pthread_exit

pthread_exit函数用于终止调用它的线程。当线程调用pthread_exit时，它会立即退出，而不会影响其他线程的执行。线程在退出时可以返回一个指向线程退出状态的指针。

例：
pthread_exit((void*)"thread_1 done");
如果线程退出出现异常呢？

如果线程出现异常，整个进程都会崩溃，所以没必要获取线程退出信号

线程的返回值，不一定返回的都是字符串，还可以是对象

线程没有非阻塞等待，线程等待很极端，要么一直等，要么不等

线程默认是：线程模式joinable的（是可以被等待的）

线程是可以被设置为分离状态的

在线程设置为分离状态后，该线程结束时系统会自动释放其所占用的资源，而不需要其他线程调用pthread_join来回收资源

pthread_detach

使用 pthread_detach 函数可以避免出现僵尸线程，提高系统效率。要使用 pthread_detach 函数，首先需要创建线程，并在创建后立即使用 pthread_detach 函数将线程设置为分离状态。

主线程可以调用pthread_detach分离新线程

新线程也可以调用pthread_detach分离自己

pthread_cancel

线程取消

Pthread_cancel(tid);

线程如果是分离的，是可以被取消的，但是不可以被等待

如果线程是被取消的，线程返回的值是-1，

全部都不是系统直接提供的接口，而是原生线程库pthread（默认是os自带的）提供的接口

linux中的线程被叫作用户级线程

系统库调用问题

线程要有独立属性

1）硬件上下文

2）栈：

新线程的栈，在库维护

默认地址空间中的栈，由主线程使用

clone 是一个系统调用，用于创建一个新的进程或线程。与 fork 系统调用不同的是，clone 允许创建的新进程或线程与父进程或线程共享某些资源，如内存空间、文件描述符等，从而实现更灵活的进程/线程管理。

clone 的原型如下：

int clone(int (*fn)(void *), void *child_stack, int flags, void *arg, ...);

其中参数含义如下：

* fn：指向新进程/线程执行的函数指针

* child_stack：指向新进程/线程栈的指针

* flags：用于指定创建新进程/线程的标志

* arg：传递给新进程/线程执行函数的参数

clone 的常用标志包括：

* CLONE_VM：共享内存空间

* CLONE_FS：共享文件系统信息

* CLONE_FILES：共享文件描述符

* CLONE_SIGHAND：共享信号处理器

线程库不仅要管理每个线程tcb，还要提供一些方法（pthread_create/pthread_join,pthread_cancel/pthread_self）

线程的局部存储

在 C/C++ 中，__thread 是一种线程局部存储（Thread-Local Storage，TLS）的实现方式，用于声明线程私有变量。在使用 __thread 关键字声明的变量中，每个线程都会有自己独立的变量副本，不同线程之间互不影响。

__thread int g_val=100;//线程的局部存储

g_val 被声明为一个 __thread 变量，其初始值为 100。这意味着每个线程都会有一个名为 g_val 的变量，且其初始值为 100。不同线程中对 g_val 的操作都是互相独立的，一个线程修改 g_val 的值不会影响到其他线程中 g_val 的值。

线程可以进行fork？线程可以进行exec*程序替换吗？

可以fork，就是整个进程创建了一个子进程

程序替换之后，整个进程会被替换，所以建议，线程直接程序替换