【Linux】多线程概念 | POSIX线程库

文章目录

  • 一、线程的概念
    • 1. 什么是线程
      • Linux下并不存在真正的多线程，而是用进程模拟的！
      • Linux没有真正意义上的线程相关的系统调用！
      • 原生线程库pthread
    • 2. 线程和进程的联系和区别
    • 3. 线程的优点
    • 4. 线程的缺点
    • 5. 线程异常
    • 6. 线程用途
  • 二、二级页表
  • 三、进程vs线程
  • 四、Linux线程控制
    • 1. POSIX线程库
    • 2. 线程创建
      • 让主线程创建一批新线程
      • 获取线程ID
    • 3. 线程等待
      • 等待线程的函数叫做pthread_join
    • 4. 线程终止
    • 5. 线程分离
    • 6. 线程ID的本质和进程地址空间布局

Linux多线程重点：

  • 1.了解线程概念，理解线程与进程区别与联系。
  • 2.学会线程控制，线程创建，线程终止，线程等待。
  • 3.了解线程分离与线程安全概念。
  • 4.学会线程同步。
  • 5.学会使用互斥量，条件变量，posix信号量，以及读写锁。
  • 6.理解基于读写锁的读者写者问题。

一、线程的概念

1. 什么是线程

课本观点：线程是比进程更加轻量化的一种执行流 / 线程是在进程内部执行的一种执行流
我们的观点：线程是CPU调度的基本单位 / 进程是承担系统资源的基本实体。

换言之，当我们创建进程时是创建一个task_struct、创建地址空间、维护页表，然后在物理内存当中开辟空间、构建映射，打开进程默认打开的相关文件、注册信号对应的处理方案等等。

  • 在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”。
  • 一切进程至少都有一个执行线程。
  • 线程在进程内部运行，本质是在进程地址空间内运行。
  • 在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更轻量化，从今天开始，我们把pcb称为轻量级进程（Light-weight process）。
  • 透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。

请添加图片描述

在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。

但也有支持真的线程的操作系统，比如Windows操作系统，因此Windows操作系统系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂得多。

Linux下并不存在真正的多线程，而是用进程模拟的！

操作系统中存在大量的进程，一个进程内又存在一个或多个线程，因此线程的数量一定比进程的数量多，当线程的数量足够多的时候，很明显线程的执行粒度要比进程更细。

如果一款操作系统要支持真的线程，那么就需要对这些线程进行管理。比如说创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等，所有的这一套相比较进程都需要另起炉灶，搭建一套与进程平行的线程管理模块。

因此，如果要支持真的线程一定会提高设计操作系统的复杂程度。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。

但也有支持真的线程的操作系统，比如Windows操作系统，因此Windows操作系统系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂得多。

Linux没有真正意义上的线程相关的系统调用！

既然在Linux中都没有真正意义上的线程了，那么自然也没有真正意义上的线程相关的系统调用了。但是Linux可以提供创建轻量级进程的接口，也就是创建进程，共享空间，其中最典型的代表就是vfork函数。

pid_t vfork(void);

vfork函数的返回值与fork函数的返回值相同：

  • 给父进程返回子进程的PID。
  • 给子进程返回0。

vfork的主要作用是为了在创建新进程时减少资源的开销，尤其是在子进程很快就会调用exec的情况下。它在性能上优于fork，但由于其特殊的语义，要小心使用以避免潜在的问题。在vfork中，父进程会被阻塞，直到子进程调用exec或者exit。这是因为子进程共享父进程的地址空间，如果父进程在子进程修改了这个地址空间之前继续执行，可能导致未定义的行为。

只不过vfork函数创建出来的子进程与其父进程共享地址空间，例如在下面的代码中，父进程使用vfork函数创建子进程，子进程将全局变量g_val由100改为了200，父进程休眠3秒后再读取到全局变量g_val的值。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int g_val = 100;
int main()
{pid_t id = vfork();if (id == 0){//childg_val = 200;printf("child:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);exit(0);}//fathersleep(3);printf("father:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);return 0;
}

原生线程库pthread

在Linux中，站在内核角度没有真正意义上线程相关的接口，但是站在用户角度，当用户想创建一个线程时更期望使用thread_create这样类似的接口，而不是vfork函数，因此系统为用户层提供了原生线程库pthread。

原生线程库实际就是对轻量级进程的系统调用进行了封装，在用户层模拟实现了一套线程相关的接口。

因此对于我们来讲，在Linux下学习线程实际上就是学习在用户层模拟实现的这一套接口，而并非操作系统的接口。

pthread库并不是基于vfork来创建线程的。pthread库通常使用底层的系统调用，如clone。

2. 线程和进程的联系和区别

线程的特点：

  1. 线程创建更简单
  2. 线程是在进程内部执行的本质是：线程在进程的地址空间中运行
  3. Linux下的线程是用进程的pcb模拟的，所以Linux下的线程是轻量级进程。
  4. OS如果要支持线程，也像进程一样必须先管理进程，先描述再组织：TCB （T是thread）

进程的特点：

  1. 进程 = 内核数据结构 + 代码和数据

以前我们讲的进程：内部只有一个执行流的进程
今天我们讲的进程：内部可以有多个执行流的进程

3. 线程的优点

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

[!info] 为什么线程切换效率高？

  1. 要换的寄存器少
  2. 不需要重新更新cache

4. 线程的缺点

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

5. 线程异常

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

6. 线程用途

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

二、二级页表

在Linux下，虚拟内存管理使用页表来实现虚拟地址到物理地址的映射。对于32位的机器，虚拟地址空间是4GB（232），即这张表一共有232个映射表项：请添加图片描述

每一个表项中除了要有虚拟地址和与其映射的物理地址以外，实际还需要有一些权限相关的信息，比如我们所说的用户级页表和内核级页表，实际就是通过权限进行区分的：

请添加图片描述

每个应表项中存储一个物理地址和一个虚拟地址就需要8个字节，考虑到还需要包含权限相关的各种信息，这里每一个表项就按10个字节计算。
这里一共有232个表项，也就意味着存储这张页表我们需要用232 * 10个字节，也就是40GB。而在32位平台下我们的内存可能一共就只有4GB，也就是说我们根本无法存储这样的一张页表。

因此所谓的页表并不是单纯的一张表！

在32位Linux系统中，最常见的是使用两级页表（也称为二级页表），即页目录表和页表：
请添加图片描述

这实际上就是我们所谓的二级页表，其中页目录项是一级页表，页表项是二级页表。

32位系统下因为地址空间大小限制，虚拟地址空间大小为4GB。即使使用最小的页面大小（通常是4KB），也需要232个页面来覆盖整个地址空间。如果使用单层页表，那么需要232个页表项来进行映射，每个页表项占用4字节（32位系统），因此单个页表需要大约2^32 * 10个字节的空间。而这只是一个页表，如果是单层映射，需要存储整个地址空间的映射，这将需要非常大的空间，这在32位系统下是不切实际的。

因此，为了在32位Linux系统中实现有效的内存管理，需要使用二级页表来平衡地址空间大小的限制和内存管理的效率要求。划分页表的本质是划分进程地址空间！

三、进程vs线程

进程是承担分配系统资源的基本实体，线程是CPU调度的基本单位。

线程与进程共享的内容：

  • 因为是在同一个地址空间，因此所谓的代码段（Text Segment）、数据段（Data Segment）都是共享的：

    • 如果定义一个函数，在各线程中都可以调用。
    • 如果定义一个全局变量，在各线程中都可以访问到。

  • 进程资源和环境：

    • 文件描述符表。（进程打开一个文件后，其他线程也能够看到）
    • 每种信号的处理方式。（SIG_IGN、SIG_DFL或者自定义的信号处理函数）
    • 当前工作目录。（cwd）
    • 用户ID和组ID。

每个线程独有的数据：

  • 线程ID。
  • 一组寄存器。（存储每个线程的上下文信息）
  • 栈。（每个线程都有临时的数据，需要压栈出栈）
  • errno。（C语言提供的全局变量，每个线程都有自己的）
  • 信号屏蔽字。
  • 调度优先级。

四、Linux线程控制

1. POSIX线程库

pthread（POSIX Threads）是一种跨平台的线程库标准。POSIX Threads定义了一套线程API规范，可以在多个操作系统上使用，包括Linux。在Linux系统中，pthread库是一种实现这个规范的库，用于创建和管理线程。因此，pthread常常被称为Linux下的原生线程库，指的是它是Linux上支持POSIX线程规范的一种库。

pthread线程库是应用层的原生线程库：

  • 应用层指的是这个线程库并不是系统接口直接提供的，而是由第三方帮我们提供的。
  • “原生”指的是大部分Linux系统都会默认带上该线程库。
  • 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的。
  • 要使用这些函数库，要通过引入头文件<pthreaad.h>。
  • 链接这些线程函数库时，要使用编译器命令的“-lpthread”选项。
系统调用接口
用户和用户操作接口
Linux提供的轻量级进程 - LWP
用户
pthread线程库

错误检查：

  • 传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
  • pthreads函数出错时不会设置全局变量errno（而大部分POSIX函数会这样做），而是将错误代码通过返回值返回。
  • pthreads同样也提供了线程内的errno变量，以支持其他使用errno的代码。对于pthreads函数的错误，建议通过返回值来判定，因为读取返回值要比读取线程内的errno变量的开销更小。

2. 线程创建

创建线程的函数叫做pthread_create

       pthread_create - create a new thread
SYNOPSIS#include <pthread.h>int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);Compile and link with -pthread.

参数说明：

  • thread：获取创建成功的线程ID，该参数是一个输出型参数。
  • attr：用于设置创建线程的属性，传入nullptr表示使用默认属性。
  • start_routine：该参数是一个函数地址，表示线程例程，即线程启动后要执行的函数。
  • arg：传给线程例程的参数。

线程创建成功返回0，失败返回错误码。

使用ps -aL命令，可以显示当前的轻量级进程。

  • 默认情况下，不带-L，看到的就是一个个的进程。
  • 带-L就可以查看到每个进程内的多个轻量级进程。
while :; do ps -aL; sleep 1; done

请添加图片描述

让主线程创建一批新线程

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <functional>
#include <vector>using namespace std;using func_t = std::function<void()>;const int 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 Print()
{std::cout << "我是线程执行的大任务的一部分" << std::endl;
}// 新线程
void* ThreadRoutine(void* args)
{int a = 10;ThreadData* td = static_cast<ThreadData*>(args);while (true){std::cout << "new thread"<< " thread name: " << td->threadname << " create time: " << td->createtime << std::endl;td->func();// if(td->threadname == "thread-4")// {//     std::cout << td->threadname << " 触发了异常！！！" << std::endl;//     a /= 0; // 故意制造异常// }sleep(1);}
}int main()
{std::vector<pthread_t> pthreads;for (size_t i = 0; i < threadnum; i++){char threadname[64];snprintf(threadname, sizeof(threadname), "%s-%d", "thread", i + 1);pthread_t tid; // 线程id  typedef unsigned long int pthread_t;ThreadData* td = new ThreadData(threadname, (uint64_t)time(nullptr), Print);pthread_create(&tid, nullptr, ThreadRoutine, td);pthreads.push_back(tid);sleep(1);}std::cout << "thread id: ";for (const auto& tid : pthreads){std::cout << tid << ",";}std::cout << std::endl;while (true){std::cout << "main thread" << std::endl;sleep(3);}return 0;
}

LWP（Light Weight Process）就是轻量级进程的ID，可以看到显示的两个轻量级进程的PID是相同的，因为它们属于同一个进程：
请添加图片描述

注意： 用pthread_self函数获得的线程ID与内核的LWP的值是不相等的，pthread_self函数获得的是用户级原生线程库的线程ID，而LWP是内核的轻量级进程ID，它们之间是一对一的关系。

获取线程ID

常见获取线程ID的方式有两种：

  • 创建线程时通过输出型参数获得。
  • 通过调用pthread_self函数获得。
    pthread_t pthread_self(void);

示例：

using namespace std;const int threadnum = 5;// 新线程
void* ThreadRoutine(void* args)
{std::cout << "我是新线程，通过pthread_self获得的线程id是：" << pthread_self() << std::endl;
}int main()
{std::vector<pthread_t> pthreads;for (size_t i = 0; i < threadnum; i++){pthread_t tid; // 线程id  typedef unsigned long int pthread_t;pthread_create(&tid, nullptr, ThreadRoutine, nullptr);pthreads.push_back(tid);sleep(1);}std::cout << "直接打印pthread_t线程id：" << std::endl;for (const auto& tid : pthreads){std::cout << tid << std::endl;}// 线程等待for (const auto& tid : pthreads){pthread_join(tid, nullptr);}return 0;
}

请添加图片描述

线程ID与内核的LWP的值是不相等的：

  • pthread_self函数获得的是用户级的POSIX程库的线程ID
  • LWP是内核的轻量级进程ID
  • 它们之间是一对一的关系

3. 线程等待

等待线程的函数叫做pthread_join

int pthread_join(pthread_t thread, void **retval);
  • thread：被等待线程的ID。
  • retval：线程退出时的退出码信息，这是一个输出型参数

总结如下：

  • 如果thread线程通过return返回，retval所指向的是thread线程函数的返回值。

  • 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED，用grep命令查询它： 请添加图片描述

    grep -ER "PTHREAD_CANCELED" /usr/include/

  • 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。

  • 如果对thread线程的终止状态不感兴趣，可以传nullptr给retval参数。

[!Question] 为什么线程退出时只能拿到线程的退出码？

如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过wait函数或是waitpid函数的输出型参数status，获取到退出进程的退出码、退出信号以及core dump标志。

那为什么等待线程时我们只能拿到退出线程的退出码？难道线程不会出现异常吗？

线程在运行过程中当然也会出现异常，线程和进程一样，线程退出的情况也有三种：

  1. 代码运行完毕，结果正确。
  2. 代码运行完毕，结果不正确。
  3. 代码异常终止。

因此我们也需要考虑线程异常终止的情况，但是pthread_join函数无法获取到线程异常退出时的信息。因为线程是进程内的一个执行分支，如果进程中的某个线程崩溃了，那么整个进程也会因此而崩溃，此时我们根本没办法执行pthread_join函数，因为整个进程已经退出了。

例如，我们在线程的执行例程当中制造一个除零错误，当某一个线程执行到此处时就会崩溃，进而导致整个进程崩溃。

// 新线程
void* ThreadRoutine(void* args)
{int a = 10;ThreadData* td = static_cast<ThreadData*>(args);while (true){std::cout << "new thread"<< " thread name: " << td->threadname << " create time: " << td->createtime << std::endl;td->func();if(td->threadname == "thread-4"){std::cout << td->threadname << " 触发了异常！！！" << std::endl;a /= 0; // 故意制造异常}sleep(1);}
}

请添加图片描述

4. 线程终止

如果需要只终止某个线程而不是终止整个进程，可以有三种方法：

  1. 从线程函数return。
  2. 线程可以自己调用pthread_exit函数终止自己。
  3. 一个线程可以调用pthread_cancel函数终止同一进程中的另一个线程。

5. 线程分离

  • 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。
  • 但如果我们不关心线程的返回值，join也是一种负担，此时我们可以将该线程进行分离，后续当线程退出时就会自动释放线程资源。
  • 一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧在该进程内运行，甚至这个线程崩溃了一定会影响其他线程，只不过这个线程退出时不再需要主线程去join了，当这个线程退出时系统会自动回收该线程所对应的资源。
  • 可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离。
  • joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

分离线程的函数叫做pthread_detach

int pthread_detach(pthread_t thread);

参数说明：

  • thread：被分离线程的ID。

返回值说明：

  • 线程分离成功返回0，失败返回错误码。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>void* Routine(void* arg)
{pthread_detach(pthread_self());char* msg = (char*)arg;int count = 0;while (count < 5){printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self());sleep(1);count++;}pthread_exit((void*)6666);
}
int main()
{pthread_t tid[5];for (int i = 0; i < 5; i++){char* buffer = (char*)malloc(64);sprintf(buffer, "thread %d", i);pthread_create(&tid[i], NULL, Routine, buffer);printf("%s tid is %lu\n", buffer, tid[i]);}while (1){printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self());sleep(1);}return 0;
}

请添加图片描述

6. 线程ID的本质和进程地址空间布局

  • pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中，该线程ID和内核中的LWP不是一回事。
  • 内核中的LWP属于进程调度的范畴，因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
  • pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，这个ID属于NPTL线程库的范畴，线程库的后续操作就是根据该线程ID来操作线程的。
  • 线程库NPTL提供的pthread_self函数，获取的线程ID和pthread_create函数第一个参数获取的线程ID是一样的。

pthread_t到底是什么类型呢？

首先，Linux不提供真正的线程，只提供LWP，也就意味着操作系统只需要对内核执行流LWP进行管理，而供用户使用的线程接口等其他数据，应该由线程库自己来管理，因此管理线程时的“先描述，再组织”就应该在线程库里进行。

通过ldd命令可以看到，我们采用的线程库实际上是一个动态库。
请添加图片描述

进程运行时动态库被加载到内存，然后通过页表映射到进程地址空间中的共享区，此时该进程内的所有线程都是能看到这个动态库的。请添加图片描述

我们说每个线程都有自己私有的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。除此之外，每个线程都有自己的struct pthread，当中包含了对应线程的各种属性；每个线程还有自己的线程局部存储，当中包含了对应线程被切换时的上下文数据。
每一个新线程在共享区都有这样一块区域对其进行描述，因此我们要找到一个用户级线程只需要找到该线程内存块的起始地址，然后就可以获取到该线程的各种信息。

请添加图片描述

上面我们所用的各种线程函数，本质都是在库内部对线程属性进行的各种操作，最后将要执行的代码交给对应的内核级LWP去执行就行了，也就是说线程数据的管理本质是在共享区的。

pthread_t到底是什么类型取决于实现，但是对于Linux目前实现的NPTL线程库来说，线程ID本质就是进程地址空间共享区上的一个虚拟地址，同一个进程中所有的虚拟地址都是不同的，因此可以用它来唯一区分每一个线程。

例如，我们也可以尝试按地址的形式对获取到的线程ID进行打印。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/557394.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

第二十八天-ES6标准入门和Flex布局

第二十八天-ES6标准入门和Flex布局

目录 1.ES6标准入门 2.ES6与JavaScript关系 3.ES6常用新特性 1.变量与常量 1.let三大特性 2.常量三大特征 2.解构赋值 1.数组解构赋值 2.对象解构赋值 3.字符串解构赋值 3.函数与箭头函数 1.函数 2.箭头函数 4.JS的面向对象编程 5.模块化 export使用 import使用…
阅读更多...
Spring——IOC容器介绍

Spring——IOC容器介绍

启动ioc容器后 1、Spring容器读取完bean配置信息&#xff08;1、XML中的bean配置信息 2、读取java类中Configuration注解配置的bean信息&#xff09;后&#xff0c;加载到Bean定义的注册表中 2、根据Bean的注册表来创建实例Bean 3、将创建好的Bean实例再放到Spring容器中&…
阅读更多...
【Godot4.2】Rect2拓展——mRect2类

【Godot4.2】Rect2拓展——mRect2类

概述 Rect2存在一些问题&#xff0c;比如难以获取除position、end和center之外的其他点。虽然计算并不复杂&#xff0c;就是简单的向量加减。但每次手动计算则比较麻烦。 其实在ShapePoints静态函数库中&#xff0c;已经尝试返回矩形的四个顶点&#xff0c;用于绘制矩形。 # …
阅读更多...
c++的学习之路：2、入门（1）

c++的学习之路：2、入门（1）

一、 C关键字 c的关键字要比c语言要多31个足足有63个&#xff0c;这里我只是了解了下每个有啥作用&#xff0c;具体使用方法以及更多的知识将在后续学习中&#xff0c;慢慢扩展使用&#xff0c;下方表格就是c的63个关键字 asmdoifreturntryautodoubleinlinetypedefdynamic_ca…
阅读更多...
归并算法详细解析

归并算法详细解析

归并排序 1945年&#xff0c;约翰冯诺依曼&#xff08;John von Neumann&#xff09;发明了归并排序&#xff0c;这是典型的分治算法的应用。归并排序&#xff08;Merge sort&#xff09;是建立在归并操作上的一种有效的排序算法&#xff0c;该算法是采用分治法&#xff08;Di…
阅读更多...
公司系统中了.rmallox勒索病毒如何恢复数据？

公司系统中了.rmallox勒索病毒如何恢复数据？

早晨上班时刻&#xff1a; 当阳光逐渐洒满大地&#xff0c;城市的喧嚣开始涌动&#xff0c;某公司的员工们纷纷踏入办公大楼&#xff0c;准备开始新的一天的工作。他们像往常一样打开电脑&#xff0c;准备接收邮件、查看日程、浏览项目进展。 病毒悄然发作&#xff1a; 就在员…
阅读更多...
Python学习：元组

Python学习：元组

Python 元组概念 Python 中的元组&#xff08;tuple&#xff09;是不可变的有序集合。它是一种数据类型&#xff0c;类似于列表&#xff08;list&#xff09;&#xff0c;但在创建后不能被修改。元组使用圆括号 () 来表示&#xff0c;其中的元素可以是任意类型&#xff0c;并且…
阅读更多...
“洞见·智领未来——2024行业开局暨成渝（内江）服务外包产业发展大会”共商服务外包新未来新业态

“洞见·智领未来——2024行业开局暨成渝（内江）服务外包产业发展大会”共商服务外包新未来新业态

3月19日-20日&#xff0c;由中国信息协会、中共内江市委、内江市人民政府指导&#xff0c;中国信息协会数字经济专委会、中共内江市东兴区委、内江市东兴区人民政府共同主办&#xff0c;鸿联九五集团、首席客户官百人会&#xff08;CCO100&#xff09;承办的“洞见 智领未来—…
阅读更多...
Spring学习记录之注解开发

Spring学习记录之注解开发

前面我们已经了解了Spring是如何创建Bean以及完成依赖注入的&#xff0c;但我们会发现&#xff0c;其似乎并没有达到简化开发的目的&#xff0c;这是因为 我们还没有接触到注解开发。 注解开发之组件 我们在要使用Bean的地方使用Comonpent&#xff08;组件&#xff09;注解&a…
阅读更多...
Linux 文件系统：重定向、缓冲区

Linux 文件系统：重定向、缓冲区

目录 一、重定向 1、输出重定向 2、输入重定向 3、追加重定向 4、dup2 系统调用 二、理性理解Linux系统下“一切皆文件” 了解硬件接口 三、缓冲区 1、为什么要有缓冲区? 2、刷新策略 3、缓冲模式改变导致发生写时拷贝 未创建子进程时 创建子进程时 使用fflush…
阅读更多...
某招聘系统0day挖掘（获取4站点报告证书）

某招聘系统0day挖掘（获取4站点报告证书）

前言： 21年的挖的漏洞了 漏洞均已提交且均已修复，这里文章只做技术交流 挖掘过程 对我来说，毕竟喜欢直接黑盒挖0day，一个0day挖到后就可以刷上百分。 如该系统正常找了一个招聘系统用的比较多的 如该通用系统，该通用系统存在一个注册功能 正常的进行注册一个账户进去…
阅读更多...
算法打卡day11

算法打卡day11

今日任务&#xff1a; 1&#xff09;239. 滑动窗口最大值 2&#xff09;347.前 K 个高频元素 239. 滑动窗口最大值 题目链接&#xff1a;239. 滑动窗口最大值 - 力扣&#xff08;LeetCode&#xff09; 给定一个数组 nums&#xff0c;有一个大小为 k 的滑动窗口从数组的最左侧移…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023