最新资讯

  • 【Linux】解锁操作系统潜能，高效线程管理的实战技巧

【Linux】解锁操作系统潜能，高效线程管理的实战技巧

2025-04-28 02:00:40 1 阅读

目录

  • 1. 线程的概念
  • 2. 线程的理解
  • 3. 地址空间和页表
  • 4. 线程的控制
    • 4.1. POSIX线程库
    • 4.2 线程创建 — pthread_create
    • 4.3. 获取线程ID — pthread_self
    • 4.4. 线程终止
    • 4.5. 线程等待 — pthread_join
    • 4.6. 线程分离 — pthread_detach
  • 5. 线程的特点
    • 5.1. 优点
    • 5.2. 缺点
    • 5.3. 线程异常
  • 6. 进程 VS 线程
  • 7. 线程管理
    • 7.1. 线程ID的本质
    • 7.2. 线程局部存储(TLS）
  • 8. 实现多线程任务
  • 9. C++11线程的封装

1. 线程的概念

1.线程：是进程内部的一个执行分支(执行流)、是CPU调度的基本单位。

  • 由于线程是进程内部的执行分支，多个线程可以在同一进程内部并发执行，提高程序的执行效率和响应速度。
  • 由于线程是CPU调度的基本单位，使得OS能够高效地管理和分配线程的执行，提高了资源利用率和响应时间。

Tips：线程在进程内部运行，本质是在进程的地址空间内运行，意味着线程可以直接访问进程地址空间。

程序的代码段包含了所有的函数和指令，每个函数在编译后都会形成一个代码块，每个代码块都有一个入口地址，这个地址是函数名的符号地址。

在单进程中，函数的调用通常是串行调用，即：一个函数调用完后才会调用另外一个函数。将代码分成多个部分，每个部分由不同的执行流(线程或进程)执行，这样可以将原本串行执行的任务变为并行执行，提高效率。

进程需要访问的资源(如 : 代码、数据、静态库、动态库、系统调用等)都通过地址空间来找到，每个资源在地址空间中都有对应的虚拟地址来标识和访问，所以地址空间和地址空间上的虚拟地址本质上是进程的一种"资源"。

2. 线程的理解

一、linux、windows对于线程设计

  1. 创建新的线程，系统只需要创建task_struct，不需要为新的线程分配地新的址空间和页表资源，新线程与其所属的进程共享同一份地址空间和页表，所以进程的地址空间对于线程来说是可见的，线程之间可以直接地共享数据，无需通过进程间通信(IPC)机制， 即：同一进程内的多个线程之间共享地址空间和其他资源，这使得线程的创建和切换更加高效。

问1：为什么Linux中"线程"这么设计？

简化实现、提高效率、灵活性：Linux设计者认为，进程和线程都是执行流，具有很多的相似性(如 : 都需要维护上下文数据、调度等)，所以没必要为线程单独设计数据结构和算法，直接复用进程的数据结构和算法，即：用进程模拟线程。

windows中线程的设计：系统会为线程创建tcb(线程控制块)结构体对象，用来描述线程相关的属性，再加其添加到特定的数据结构中。线程管理拥有一套自己的数据结构与算法。

二、进程本质概念、轻量级进程

  1. 不要站在调度角度理解进程，而应该站在内核角度理解理解进程：进程是承担分配系统资源的基本实体。

eg：承担分配社会资源的基本实体是家庭，家庭中每个成员都在执行自己特定的任务，但公共的任务是让这个家庭生活变得越来越好，即：家庭是进程、家庭成员是线程。

  1. 关于调度问题：中，所有调度执行的执行流都被称为轻量级进程，线程也被称为轻量级进程。

3. 地址空间和页表

一、OS管理内存、页框

1.页框或页帧：物理内存中一个固定大小的区域，通常大小为4KB，它是OS系统进行内存管理的基本单位，用于存放数据和指令。

4KB为内存管理和磁盘管理的基本单位。

二、虚拟地址到物理地址的转化

  1. 在Linux系统中，虚拟地址到物理地址的转化是通过两级页表来实现的，地址空间的大小为4GB，虚拟地址通常被划分为三个部分：高10位作为页目录索引、中间10位作为页表索引、低12位作为页内偏移量。

  2. 页目录的查找：使用虚拟地址的高10位作为页目录索引，在页目录表中查找对应的页目录项。页目录表是一个数组，其中的每一项指向页表的物理地址。

  3. 页表的查找：用虚拟地址的中间10位作为页表索引，在对应的页表中查找对应的页表项。页表是一个数组，其中的每一项指向物理页框地址。

  4. 线程要访问的代码，在内存中物理地址的计算：物理地址 = 页表项中的物理页框地址 + 页内偏移量(虚拟地址的低12位)。

多个执行流如何进行代码划分？

函数编译后可以被看作一段连续的代码块，函数名作为这个代码块的入口地址。

在链接阶段，这些函数(代码块)最终会被放置在程序的最终可执行文件中，链接器会将这些代码块按照一定的顺序进行排列，并分配唯一的地址范围。即：所有函数，都要按照地址空间进行统一编址，所有函数的代码块，在地址空间中都有唯一的地址范围。

OS通过页表和内存保护机制，确保每个进程只能访问自己有权访问的内存区域。

不同执行流都有自己的执行起点，也就是线程函数入口地址(虚拟地址)，通过页表映射就可以找到对应物理内存的代码，从而执行相应的代码。

4. 线程的控制

4.1. POSIX线程库

  1. POSIX线程库：是POSIX标准中定义的线程库，提供了一套标准的线程函数。

  • 与线程有关的函数构成了一个完整的序列，绝大多数函数的名字都是以"pthread_"开头的。

  • 使用线程库函数，必须加上头文件#include，链接线程库函数时，编译器要使用"-lpthread"命令。

Linux中并没有为线程设计独立的结构，线程是通过轻量级进程来实现的，即：Linux中无线程相关的系统调用，只有轻量级进程的系统调用。

用户不知道轻量级进程这个概念，只认识进程和线程，OS就在软件层将轻量级进程的系统调用封装成原生线程库(pthread库)，并提供给用户熟悉的线程相关接口。

POSIX线程库(pthread库)是在用户层实现的，不属于内核的一部分，所以pthread库也被称为用户级线程库。

4.2 线程创建 — pthread_create

int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void *( * start_routine)(void *), void * arg)；

  1. 功能：创建新线程。

  2. 参数：thread：输出型参数，存储新线程标识符(ID)； attr：设置新线程的属性，如果不需要设置特殊属性，可以传入NULL，NULL表示使用默认属性； start_rountin：新线程的入口函数； arg：传递给入口函数的参数。

void*可以接收任意类型指针，可以与任意类型指针进行强制类型转换。

  1. 返回值：成功返回0，失败返回错误码。

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

#include
#include
#include

using namespace std;

void* newthreadrun(void* args)
{
    while(true)  //新线程
    {
        cout << "I am a newthread, pid: " << getpid() << endl;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid; 
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    //新线程、主线程谁先运行: 不确定, 由调度器决定
    while(true)  //主线程
    {
        cout << "I am a mainthread, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

ps -aL | head -1 && ps -aL | grep xxx ；

  • 功能：显示当前进程xxx的所有轻量级进程(线程)的详细信息。

  • ps -aL是显示系统中所有进程的所有轻量级进程(线程)的详细信息。

  • 对于进程内部只有一个执行流的进程(单进程)，LWP == PID，所以OS使用LWP来进行调度。

4.3. 获取线程ID — pthread_self

pthread_t pthread_self(void)；

  • 功能：获取当前进程的标识符(ID)。
#include
#include
#include
#include
#include

using namespace std;

string ToHex(pthread_t id) //10进制转16进制(地址)
{
    char buffer[126];
    snprintf(buffer, sizeof(buffer), "0x%lx", id);
    return buffer;
}


void* newthreadrun(void* args)
{
    while(true)  //新线程
    {
        cout << "I am a newthread, id: " << ToHex(pthread_self()) << endl;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid; 
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    while(true)  //主线程
    {
        cout << "I am a mainthread, id: " << ToHex(pthread_self()) << endl;
        sleep(1);
    }

    return 0;
}

  1. LWP(轻量级进程)：是内核中用于标识一个执行流的唯一标识符。
  • 在大多数OS内核中，线程是通过轻量级进程(LWP)来实现的，LWP提供了线程在内核中的表示，并且每个LWP都有唯一的标识符(LWP ID)。
  1. tid：用户空间中线程唯一标识符。
  • 原生线程库维护这些标识符tid，在创建线程时，线程库会分配唯一的tid给每个新线程。
  1. LWP与tid关系

一对一：用户空间中的线程都会对应内核中的LWP，意味着每个线程在内核和用户空间都有一个唯一的标识符。在用户空间中，线程库维护一个线程ID的映射表，将用户空间的线程ID与内核中轻量级进程(LWP) ID 关联起来，

LWP是由OS内核管理的，tid是由线程库管理的。

用途：LWP在内核调度和线程管理中使用，tid在用户空间编程和调试中使用。

4.4. 线程终止

  1. return：线程函数执行完最后一行代码或遇到return语句，线程会自动终止。
  • 这种方法对于主线程不适用，因为main函数return相当于调用了exit，exit函数终止整个进程，会导致其他线程都被终止。
  1. void pthread_exit(void* retval)；

功能：显示地终止当前进程。

pthread_exit不会自动释放资源，需要使用来回收资源。

retval参数：线程退出时的返回值，其他线程可以通过pthread_join函数获取到这个返回值，如果线程没有设置返回值(即 : 没有调用pthread_exit函数、没有return、pthread_exit函数的参数为NULL)，则pthread_join获取到的返回值是未定义的。

  1. int pthread_cancel(pthread_t thread)；

功能：用于请求终止指定线程的执行，这个请求不会立即生效，会在合适的时机终止，具体行为取决于目标线程释放设置了取消点，以及是否启用了取消状态。

thread参数：要终止线程的标识符(ID)。

返回值：成功返回0，失败返回非0错误码。

前提：在调用这个函数之前，主线程要确保目标线程创建成功并启动，如果目标线程尚未启动，调用此函数将无效，甚至可能导致未定义行为。

💡Tips：return、pthread_exit返回的指针所指向的内存单元，必须是全局的或者malloc分配的，不能在线程的独立栈上分配，因为当其他线程得到这个返回指针时，线程函数已经退出了。

4.5. 线程等待 — pthread_join

问：为什么需要线程等待？

当一个线程退出时，不会自动释放资源，它的资源(如 : 线程栈、线程控制块等)仍存放在进程的地址空间内，造成内存泄漏。

创建新线程，不会复用刚才退出线程的资源，导致资源浪费。

int pthread_join(pthread_t thread，void** retval)；

  1. 功能：等待指定的线程终止，阻塞等待。

  2. 参数：thread：要等待的线程标识符(ID); retval：接收被等待线程的返回值，获取此线程的执行情况。

  3. 返回值：成功返回0，失败返回错误码。

  4. 调用pthread_join的线程将挂起等待，直到id为thread的线程终止，thread线程以不同的方式终止，则pthread_join得到的终止状态是不同的。

如果thread线程通过return返回，retval所指向的单元里存放的是thread函数的返回值。

如果一个线程被另一个线程调用pthread_cancel异常终止，retval所指向的单元里存放的是

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

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

#include
#include
#include
#include
#include

using namespace std;

string ToHex(pthread_t id) //10进制转16进制(地址)
{
    char buffer[126];
    snprintf(buffer, sizeof(buffer), "0x%lx", id);
    return buffer;
}


void* thread1(void* args)
{
    cout << "thread1 is running...." << endl;
    int* p1 = (int*)malloc(sizeof(int));
    *p1 = 1; 
    return (void*)p1;  
}

void* thread2(void* args)
{
    cout << "thread2 is running...." << endl;
    int* p2 = (int*)malloc(sizeof(int));
    *p2 = 2;
    pthread_exit((void*)p2);
}

void * thread3(void* args)
{
    while(true)
    {
        cout <<"throw3 is running..." << endl;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid;
    void* retval = nullptr;

    pthread_create(&tid, nullptr, thread1, nullptr);
    pthread_join(tid, &retval);
    cout << "thread1 ret: " << *(int*)retval << ", thread1 id" << ToHex(pthread_self()) << endl;

    pthread_create(&tid, nullptr, thread2, nullptr);
    pthread_join(tid, &retval);
    cout << "thread2 ret: " << *(int*)retval << ", thread2 id" << ToHex(pthread_self()) << endl;

    pthread_create(&tid, nullptr, thread3, nullptr);
    pthread_cancel(tid);
    pthread_join(tid, &retval);
    if(retval == PTHREAD_CANCELED)
        cout << "thread3 return, thread3 id: "<< ToHex(pthread_self()) << ", return code: PTHREAD_CANCELED
" << endl;
    else
        cout << "thread3 return, thread3 id: "<< ToHex(pthread_self()) << ", return code: NULL" << endl;

    return 0;
}

pthread_join不考虑线程异常情况，因为它会导致整个进程立即退出，pthread_join无法拿到子线程退出情况。

4.6. 线程分离 — pthread_detach

int pthread_detach(pthread_t thread)；

  1. 功能：分离一个进程。

  2. 返回值：成功返回0，失败返回错误码。

  3. 默认情况下，新建的线程是joinable的，线程退出后，必须对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。

  4. 如果主线程不关心新线程的执行情况(即: 返回值)，join是一种负担，新线程可以被设置为分离状态，则主线程不需要等待新线程完成，新线程在完成其工作后会自动释放其资源，不需要使用pthread_join来回收资源，如果使用了pthread_join会报错，因为无法获取其退出状态。

  5. 可以是线程组内其他线程对目标线程进行分离：pthread_detach(pthread_t thread)、也可以是线程自己分离：pthread_detach(pthread_self( ))。

  6. 线程被创建后，无论是否分离，它都会运行在主线程所在的地址空间中，这意味着新线程和主线程仍共享相同的地址空间。如果主线程退出，则分离后的线程也会退出。即：分离后的线程仅仅不需要主线程join，其他都与线程的特性保持一致。

5. 线程的特点

5.1. 优点

  1. 创建角度 — 创建一个新线程的代价要比创建一个新进程小得多。

  2. 调度角度 — 与进程之间的切换相比，线程之间的切换需要OS做的工作要少很多。

  3. 释放资源角度 — 线程占用的资源要比进程少得多。

  4. 能充分利用多处理器的可并行数量。

  5. 在等待I/O操作结束的同时，程序可执行其他计算任务。

  6. 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。

  7. I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

问：为什么线程切换在调度角度上优势比进程切换更为明显—— 面试题？

一、资源共享

  1. 每个进程都有独立的地址空间、系统资源(如:文件、设备、信号处理器等)。进程间通信需要借助IPC机制，这增加了通信的复杂性和开销。在进行进程切换时，OS需要保存和恢复整个进程的状态，包括内存管理信息、文件描述符、信号处理状态等，这进一步增加了切换的开销。

  2. 由于线程共享地址空间、系统资源、内存布局，因此通信开销较小。在进行线程切换时，OS无需保存和恢复整个进程的状态，只需要保存和恢复线程的私有数据(如：寄存器、栈指针等)。

二、上下文切换

  1. 进程上下文切换：包括CPU上下文切换(如：寄存器、程序计数器等)、内存上下文切换(如：页表、文件描述符表等)，所以在进行进程切换时，OS既需要保存和恢复进程的执行上下文(寄存器、程序计数器等)、还需要重新加载页表、文件描述符表等，这进一步增加了切换的复杂性。

  2. 线程上下文切换：由于线程共享地址空间、内存布局，不涉及内存上下文的切换。在进行线程切换时，OS只需要保存和恢复线程的执行上下文(寄存器、程序计数器等)、不需要重新加载页表、文件描述符表等，大大减少了切换的开销。

三、局部性原理 (主要问题)

  1. 进程：由于每个进程有自己的独立地址空间、内存布局，缓存中的数据在进程切换时通常会失效，需要更换当前正在使用的缓存内容，这会导致缓存命中率下降，CPU需要重新从主存储器中加载代码、数据到缓存中，增加了延迟和开销。

  2. 线程：由于线程共享地址空间、内存布局，缓存中的数据在线程切换时通常不会被丢弃，不需要更换当前正在使用的内容，线程使用的代码和数据很可能仍然在缓存中，CPU可以立即使用缓存中的数据执行指令，而无需等待从主存储器中加载数据，这提高了缓存的命中率、CPU执行速度。

CPU上集成了硬件级别的缓存(Cache L1~L3)，其工作原理如下：

缓存的设计基于局部性原理( 即：程序在运行时倾向于最近访问的数据和指令)，有两种类型，时间局部性是指如果某个数据被访问了一次，近期它可能会被再次访问，空间局部性是指如果某个数据被访问了，那么其附近的数据也有可能被访问。

缓存通常以缓存行为单位进行读写。当CPU访问某个内存地址时，它可能会将整个地址所在的缓存行加载到缓存中，有助于利用空间局部性，因为相邻的内存地址往往被一起访问。

缓存替换策略：当缓存满了而需要加载新数据时，此策略会决定哪些数据应该被丢弃。

5.2. 缺点

  1. 性能损失：一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型 线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的 同步和调度开销，而可用的资源不变。

  2. 健壮性降低：编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了 不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。

  3. 缺乏访问控制：进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。

  4. 编程难度提高：编写与调试一个多线程程序比单线程程序困难得多。

5.3. 线程异常

  1. 多线程中，任何一个线程出了异常(除零、野指针等)，都会导致整个进程退出。— 从而得知多线程代码往往健壮性不好。线程安全问题。

  2. 主线程退出 = = 进程退出 = = 所有线程退出。所以往往我们需要主线程最后退出。

  3. 总结：线程是进程的执行分支，线程出异常，就类似于进程出异常，进而触发信号机制，终止进程，则该进程内所有的线程也就随即退出。

  4. 多线程中，公共函数如果被多个进程同时进入，则该函数被重入了。

#include
#include
#include
#include
#include

using namespace std;

string ToHex(pthread_t id) //10进制转16进制(地址)
{
    char buffer[126];
    snprintf(buffer, sizeof(buffer), "0x%lx", id);
    return buffer;
}

void* newthreadrun(void* args) //子线程
{
    int cnt = 3;
    while(cnt--)
    {
        cout << "I am a newthread, id: " << ToHex(pthread_self()) << endl;
        sleep(1);
    }

    int* p = nullptr; //野指针异常
    *p = 4;

    return nullptr;
}

int main()
{
    pthread_t tid; 
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    while(true)  //主线程
    {
        cout << "I am a mainthread, id: " << ToHex(pthread_self()) << endl;
        sleep(1);
    }

    return 0;
}

6. 进程 VS 线程

  1. 进程是资源分配的基本单位，线程是调度的基本单位。

  2. 尽管线程之间共享数据，但线程也有私有数据。

  • 硬件上下文 (一组寄存器) —— 调度

  • 线程栈 —— 常规运行

  • 线程ID

  • errno

  • 调度优先级

  • 信号屏蔽字

线程栈：是一个独立的栈结构，用于存储线程执行时的局部变量、函数参数、返回地址、调用栈等信息。

  1. 进程的多个线程共享同一地址空间，所以代码段(Text Segment)、数据段(Data Segment)是共享的。

  • 代码和全局数据 ( 全局函数、全局变量 )

  • 文件描述符表

  • 每种信号的处理方式 (信号的handler表)

  • 当前工作目录pwd

  • 用户id和组id

#include
#include
#include
#include
#include

using namespace std;

//全局成员变量
int g_val = 3;

//全局成员函数
string ToHex(pthread_t id) //10进制转16进制(地址)
{
    char buffer[126];
    snprintf(buffer, sizeof(buffer), "0x%lx", id);
    return buffer;
}

void* newthreadrun(void* args) //子线程
{
    while(true)
    {
        cout << "newthread id: " << ToHex(pthread_self()) << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;
        g_val--;
        if(g_val == 0) break;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid; 
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    while(true)   //主线程
    {
        cout << "mainthread id: " << ToHex(pthread_self()) << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;
        if(g_val == 0) break;
        sleep(1);
    }

    return 0;
}

7. 线程管理

7.1. 线程ID的本质

  1. 线程ID定义：线程ID是OS用于唯一标识一个线程的标识符。
  • 在POSIX线程库(pthreads)中，线程ID的类型为pthread_t 。

  1. 线程管理：OS为了管理进程，Linux内核设计了一套专用于进程的数据结构、算法，Linux为了系统的简洁性和轻量性，并没有为线程设计一套新的数据结构和算法，而是复用了进程的数据结构和算法。

  2. 线程库通常是一个动态库，通过ldd命令可以看得到，进程运行时，动态库需要被加载到内存中，然后通过页表映射到地址空间中的共享区，地址空间的共享区可以被进程内所有的线程访问到。


  1. 线程库：提供了管理线程的一系列接口函数，实现了描述线程的数据结构和一些管理工作，即：对于线程的管理工作，由线程库来完成。


5. 线程控制块(TCB)：每个线程都有自己的TCB，包含对应线程的各种属性和状态信息。

  1. 线程栈：每个线程都有自己私有的独立栈，主线程采用的是进程地址空间中的原生栈，而其余的线程采用的是共享区中的线程库中的栈。

  2. 线程ID的本质：在NTLP线程库中，线程ID本质是一个指向线程控制块(TCB)的指针，这个指针指向共享区中的一个内存块，这个内存块(TCB)的起始地址就是线程ID。

同一个进程中所有虚拟地址都是不同的，因此可以根据虚拟地址来区分每一个线程，线程的后续操作，就是根据线程ID来进行操作的。

问：pthread_s到底是什么类型呢？

取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是地址空间上的一个地址。

7.2. 线程局部存储(TLS）

  1. 线程局部存储：是一种机制，允许每个线程拥有自己变量的副本，这些变量在每个线程中独立存在、互不影响。这种机制确保了线程数据的独立性，从而避免了全局变量或静态变量在并发环境下竞态条件和数据不一致的问题。

  2. 线程局部存储的优点：数据隔离、减少了同步开销、提高了性能。

  3. __thread关键字：用于声明线程局部存储变量，使用__thread关键字声明的变量在每个线程中都有一个独立的副本，这些副本互不影响，有助于避免线程间的竞态条件或数据不一致问题，提高线程安全性。

__thread 数据类型 变量名 ;

#include
#include
#include
#include
#include

using namespace std;

__thread int g_val = 3; //线性局部存储变量

string ToHex(pthread_t id) //10进制转16进制(地址)
{
    char buffer[126];
    snprintf(buffer, sizeof(buffer), "0x%lx", id);
    return buffer;
}

void* newthreadrun(void* args) //子线程
{
    while(true)
    {
        cout << "newthread id: " << ToHex(pthread_self()) << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;
        g_val--;
        if(g_val == 0) break;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    pthread_t tid; 
    pthread_create(&tid, nullptr, newthreadrun, nullptr);

    while(true)   //主线程
    {
        cout << "mainthread id: " << ToHex(pthread_self()) << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;
        if(g_val == 0) break;
        sleep(1);
    }

    return 0;
}

8. 实现多线程任务

  1. 在多线程中，线程函数的参数和返回值，我们可以传递 / 返回 基本数据类型(int、float、char)、指针、结构体对象、自定义类型对象作为参数 / 返回值。参数通常需要通过指针传递 / 返回值通常通过void*类型的指针返回。
#include
#include
#include
#include
#include
#include

using namespace std;

void* threadname(void* args) //参数为基本类型
{
    const string& name = static_cast<char*>(args);
    while(true)
    {
        cout << "I am " << name << endl;
        sleep(2);  
    }
    return nullptr;
}

int main()
{
    vector<pthread_t> threads;
    for(int i = 1; i <= 5; i++) //多线程创建
    {
        //错误代码，多线程共享同一块内存区域(缓冲区)
        char buffer[64]; 
        snprintf(buffer, 64, "Thread-%d", i);
        pthread_t tid;
        pthread_create(&tid, nullptr, threadname, buffer);
        threads.push_back(tid);
    }

    for(auto& e : threads) //等待多线程
        pthread_join(e, nullptr);
}

问：为什么创建的多线程名字都相同呢？

答：buffer缓冲区，用于存储线程的名字，在创建线程时传递这个缓冲区的地址给线程，因为所有线程共享这块缓冲区，那么在主线程创建新线程的过程中，缓冲区的内容会被不断修改，导致前面创建的线程读取到错误的数据。

在多线程编程中，如果多个线程共享同一块内存区域(如缓冲区)，会导致数据竞争和不一致的问题，为了确保每个线程能够正确访问和修改自己的数据，应该为每个线程分配独立的内存区域(如堆空间)。

#include
#include
#include
#include
#include

using namespace std;

void* threadname(void* args) //参数为基本类型
{
    const string& name = static_cast<char*>(args);
    while(true)
    {
        cout << "I am " << name << endl;
        sleep(2);  
    }
    return nullptr;
}

int main()
{
    vector<pthread_t> threads;
    for(int i = 1; i <= 5; i++) //多线程创建
    {
        //为每个线程分配独立的内存区域,防止出现数据竞争和不一致问题
        char* buffer = new char[64]; 
        //char buffer[64];
        snprintf(buffer, 64, "Thread-%d", i);
        pthread_t tid;
        pthread_create(&tid, nullptr, threadname, buffer);
        threads.push_back(tid);
    }

    for(auto& e : threads) //等待多线程
        pthread_join(e, nullptr);
}


#include
#include
#include
#include
#include
#include
#include

using namespace std;

#define NUM 5

//任务类
class Task 
{
public:
    Task(){ }

    ~Task(){ }

    void SetData(int x, int y) 
    {
        _x = x;
        _y = y;
    }

    int Add()
    {
        return _x + _y;
    }

private:
    int _x;
    int _y;
};

//线程类
class Thread
{
public:
    Thread(int x, int y, const string& threadname)
        :_threadname(threadname)
        { 
           _t.SetData(x, y); 
        }

    string& Threadname()
    {
        return _threadname;
    }

    int Run()
    {
        return _t.Add();
    }

    ~Thread(){ }

private:
    string _threadname; //名字
    Task _t;  //任务
};

//任务结果类
class Result
{
public:
    Result(const string& threadname, int result)
        :_threadname(threadname), _result(result)
        { }
    
    void print()
    {
        cout << _threadname << ": " << _result << endl;
    }

private:
    string _threadname;
    int _result;
};

void* handerTask(void* args)
{
    Thread* td = static_cast<Thread*>(args); //类型转换

    const string& threadname = td->Threadname();
    int result = td->Run();
    Result* res = new Result(threadname, result);
    return res;
}

int main()
{
    vector<pthread_t> id;
    vector<Result*> res;

    for(int i = 1; i <= NUM; i++)
    {
        char threadname[128];
        snprintf(threadname, sizeof(threadname), "Thread-%d", i);
        Thread* td = new Thread(10, 20, threadname);

        pthread_t tid;
        //创建新线程,参数和返回值为自定义类对象
        pthread_create(&tid, nullptr, handerTask, td); 
        id.push_back(tid);
    }

    for(auto& e : id)
    {
        void* tmp = nullptr;
        pthread_join(e, &tmp); //获取新线程的返回值(执行情况)
        res.push_back((Result*)tmp);
    }

    for(auto& e : res)
    {
        e->print();
        delete e;
    }

    return 0;
}

9. C++11线程的封装

  1. C++11通过引入头文件，为开发者提供了一套统一且高效的线程API。
  • 在编译和链接的时候通常需要加上-pthread选项，告诉编译器你需要链接pthread库。
  1. std: : thread类是C++标准库中用于创建和管理线程的核心类，它对底层线程API进行了抽象和封装，使得开发者无需关注特定OS的细节，只需要使用C++标准接口就可以创建和控制线程。这种封装方式提高了C++程序的跨平台性和可移植性。

跨平台性：C++多线程库在不同的OS上提供了统一的接口。意味着可以在不同的平台编写相同的多线程代码，而不需要关心底层的具体实现。

封装：C++多线程库封装了底层的OS线程API，如：在Linux中，使用的是POSIX线程(pthread库)，pthread库是Linux底层提供多线程的常用方式。 在Windows中，多线程的实现方式是对线程调用接口进行了封装。

#include
/*库的实现依赖于底层的线程库,
在编译和链接的时候通常需要加上-pthread选项,告诉编译器你需要链接pthread库*/
#include //定义了与多线程编程相关的类和函数
#include

using namespace std;

// 线程函数
void threadFunction(int num) 
{
    while(true)
    {
        cout << "I am newthread " << num << endl;
        sleep(1);
}
 
int main() {
    const int num = 5;
    
    //thread类,创建和管理线程
    thread t(threadFunction, num);

    while(true)
    {
        cout << "I am mainthread" << endl;
        sleep(1);
    }

    //thread类提供了join、detach成员函数来管理线程的声明周期
    t.join(); 
    
    return 0;
}


#include
#include
#include
#include
#include

using namespace std;

namespace zzx
{
    template<typename T>
    using fun_c = function<void(T)>;

    template<typename T>
    class thread
    {
      public:
        thread(fun_c<T> func, T data, const string& name = "thread none-name")  
            :_func(func), _data(data), _name(name),_stop(true)
            { }
        
        ~thread(){ }

        //注意：类成员函数,默认第一个参数为this指针,静态成员函数无this指针
        static void* threadroutine(void* args) 
        {
            thread<T>* td = static_cast<thread<T>*>(args); //强制类型转换
            td->_func(td->_data);
            return nullptr;
        }

        bool start()
        {
            //为了在静态成员函数threadroutine中访问成员变量,参数传递类对象指针(this)
            int n = pthread_create(&_tid, nullptr, threadroutine, this);
            if(n != 0) return false;
            _stop = false;
            return true;
        }

        void detach()
        {
            if(!_stop)
                pthread_detach(_tid);
        }

        void join()
        {
            if(!_stop)
                pthread_join(_tid, nullptr);
        }

        string name()
        {
            return _name;
        }

        void stop()
        {
            _stop = true;
        }

      private:
        pthread_t _tid;
        string _name;
        T _data;
        fun_c<T> _func;
        bool _stop;
    };
}

#include"Thread.hpp"
#include
#include

#define NUM 5

using namespace zzx;

void route(int num)
{
    while(num)
    {
        cout << "I am newthread, num: " << num << endl;
        num--;
        sleep(1);
    }
}

int main()
{
    vector<thread<int>> threads;
    //创建一批线程
    for(int i = 1; i <= NUM; i++)
    {    
        //堆空间,防止线程共享同一块内存区域,造成数据竞争和不一致问题
        char* buffer = new char[64];
        snprintf(buffer, 128, "thread-%d", i);
        threads.emplace_back(route, 5, buffer);
    }
    //启动一批线程
    for(auto& e : threads)
        e.start();
    //等待一批线程
    for(auto& e : threads)
    {
        e.join();
        cout << "wait thread done, thread is " << e.name() << endl;
        sleep(1);
    }

    return 0;
}

本文地址：https://www.vps345.com/4167.html

上一篇：ubuntu22.04制作本地源
下一篇：【Ubuntu】超详细安装Ubuntu系统
[2025-04-30]

Linux——基础IO

[2025-04-30]

【在Linux世界中追寻伟大的One Piece】···

[2025-04-30]

mac 卸载流氓软件安全助手

[2025-04-30]

运维打铁：Linux Centos 7 安装更新GPU···

[2025-04-30]

国内CentOS使用yum安装docker和docker-···

[2025-04-30]

Linux——基础IO

[2025-04-30]

【在Linux世界中追寻伟大的One Piece】···

[2025-04-30]

mac 卸载流氓软件安全助手

[2025-04-30]

运维打铁：Linux Centos 7 安装更新GPU···

[2025-04-30]

国内CentOS使用yum安装docker和docker-···

搜索文章

最新文章

2025-04-30

ubuntu20.04安装docker环境
2025-04-30

centos Stream 9 搭建详细教程
2025-04-30

【Linux】升级openssl版本
2025-04-30

【Docker】容器被停止/删除的方式及命令：全面解析与···
2025-04-30

【Docker】解决Docker Engine stopped

热门文章

2024-01-24

香港站群服务器如何利用CN2线路实现高速稳定连接？
2024-01-24

如何通过香港站群服务器的大带宽优势提升网站性能
2024-01-25

网站如何根据同时在线人数计算流量带宽
2024-01-26

什么是服务器上行带宽？服务器上行传输速率过大是什···
2024-01-30

服务器怎么防御CC攻击，服务器遭遇CC攻击怎么办？

所有分类

帮助文档 （2866） 香港服务器 （1263） 美国服务器 （2076） 香港站群服务器 （0） 美国站群服务器 （0）

Tags

PV计算 带宽计算 流量带宽 服务器带宽 上行带宽 上行速率 什么是上行带宽？ CC攻击 攻击怎么办 流量攻击 DDOS攻击 服务器被攻击怎么办 源IP 服务器 linux 运维 游戏 云计算 javascript 前端 chrome edge 进程 操作系统 进程控制 Ubuntu python MCP ssh ubuntu 数据库 centos oracle 关系型 安全 分布式 阿里云 网络 网络安全 网络协议 llama 算法 opencv 自然语言处理 神经网络 语言模型 deepseek Ollama 模型联网 API CherryStudio RTSP xop RTP RTSPServer 推流 视频 java 面试 性能优化 jdk intellij-idea 架构 udp unity php android Dell R750XS vue.js audio vue音乐播放器 vue播放音频文件 Audio音频播放器自定义样式 播放暂停进度条音量调节快进快退 自定义audio覆盖默认样式 harmonyos 华为 开发语言 typescript 计算机网络 rust http ssl 深度学习 YOLO 目标检测 计算机视觉 人工智能 GaN HEMT 氮化镓 单粒子烧毁 辐射损伤 辐照效应 fastapi mcp mcp-proxy mcp-inspector fastapi-mcp agent sse filezilla 无法连接服务器 连接被服务器拒绝 vsftpd 331/530 HCIE 数通 tcp/ip macos adb numpy c# Flask FastAPI Waitress Gunicorn uWSGI Uvicorn 鸿蒙 flutter Hyper-V WinRM TrustedHosts jenkins c语言 qt stm32项目 单片机 stm32 pytorch transformer Qwen2.5-coder 离线部署 debian PVE ide ai AI编程 物联网 iot pycharm golang 后端 嵌入式硬件 pip conda websocket github AI Agent windows react.js 前端面试题 node.js 持续部署 redis mybatis oceanbase rc.local 开机自启 systemd 麒麟 ollama llm chatgpt 大模型 llama3 Chatglm 开源大模型 ping++ 运维开发 机器学习 c++ 树 深度优先 图论 并集查找 换根法 树上倍增 YOLOv12 宝塔面板访问不了 宝塔面板网站访问不了 宝塔面板怎么配置网站能访问 宝塔面板配置ip访问 宝塔面板配置域名访问教程 宝塔面板配置教程 科技 个人开发 docker 容器 ffmpeg 音视频 温湿度数据上传到服务器 Arduino HTTP 银河麒麟服务器操作系统 系统激活 计算机外设 电脑 mac 软件需求 学习 uni-app 负载均衡 gitee spring boot cuda cudnn anaconda 微服务 springcloud 豆瓣 追剧助手 迅雷 nas 微信 微信分享 Image wxopensdk 嵌入式 linux驱动开发 arm开发 ESP32 vim tomcat LDAP aws googlecloud 实时音视频 Windsurf ollama下载加速 vscode 笔记 maven intellij idea 经验分享 学习方法 .netcore nginx 监控 自动化运维 智能路由器 外网访问 内网穿透 端口映射 word图片自动上传 word一键转存 复制word图片 复制word图文 复制word公式 粘贴word图文 粘贴word公式 pillow 大数据 大数据平台 .net django flask web3.py 前端框架 产品经理 agi microsoft jmeter 软件测试 DeepSeek-R1 API接口 C 环境变量 进程地址空间 sqlserver live555 rtsp rtp json html5 firefox WSL win11 无法解析服务器的名称或地址 https web安全 Kali Linux 黑客 渗透测试 信息收集 僵尸进程 apache 小程序 微信小程序域名配置 微信小程序服务器域名 微信小程序合法域名 小程序配置业务域名 微信小程序需要域名吗 微信小程序添加域名 WSL2 vue3 HTML audio 控件组件 vue3 audio音乐播放器 Audio标签自定义样式默认 vue3播放音频文件音效音乐 自定义audio播放器样式 播放暂停调整声音大小下载文件 开源 代码调试 ipdb asm 创意 社区 cpu 内存 实时 使用 C语言 YOLOv8 NPU Atlas800 A300I pro asi_bench DigitalOcean GPU服务器购买 GPU服务器哪里有 GPU服务器 Deepseek Playwright 自动化测试 数据结构 统信UOS bonding 链路聚合 make命令 makefile文件 压力测试 ESXi mount挂载磁盘 wrong fs type LVM挂载磁盘 Centos7.9 svn 自动化 ecm bpm 压测 ECS ip命令 新增网卡 新增IP 启动网卡 TRAE iftop 网络流量监控 宕机切换 服务器宕机 鸿蒙系统 华为云 AIGC webrtc 安卓 RAID RAID技术 磁盘 存储 远程工作 课程设计 数据库架构 数据管理 数据治理 数据编织 数据虚拟化 LLM java-ee HarmonyOS Next DevEco Studio dify idm 游戏服务器 Minecraft ddos gpu算力 政务 分布式系统 监控运维 Prometheus Grafana prometheus gitlab iDRAC R720xd bash docker compose ceph freebsd 信息与通信 文件系统 路径解析 Trae AI代码编辑器 AI大模型 程序员 threejs 3D zotero WebDAV 同步失败 代理模式 postgresql ansible playbook XFS xfs文件系统损坏 I_O error mongodb es jvm Dify matlab shell 磁盘监控 部署 服务器配置 tcpdump rabbitmq dell服务器 go 硬件架构 系统架构 rocketmq mysql IIS .net core Hosting Bundle .NET Framework vs2022 金融 数据挖掘 状态管理的 UDP 服务器 Arduino RTOS 腾讯云大模型知识引擎 html 驱动开发 mcu X11 Xming 集成学习 集成测试 生物信息学 openEuler 云原生 etcd 数据安全 RBAC 企业微信 Linux24.04 deepin RAGFLOW RAG 检索增强生成 文档解析 大模型垂直应用 Linux DNS minio 医疗APP开发 app开发 报错 mariadb 腾讯云 Java springboot远程调试 java项目远程debug docker远程debug java项目远程调试 springboot远程 职场和发展 交换机 硬件 设备 GPU PCI-Express 微信小程序 JAVA spring cloud jetty undertow UOS 统信操作系统 yum docker搭建nacos详解 docker部署nacos docker安装nacos 腾讯云搭建nacos centos7搭建nacos Erlang OTP gen_server 热代码交换 事务语义 DeepSeek ip 音乐服务器 Navidrome 音流 kylin 智能手机 NAS Termux Samba DeepSeek行业应用 Heroku 网站部署 jupyter excel 多进程 1024程序员节 MQTT协议 消息服务器 代码 远程 命令 执行 sshpass 操作 hugo zabbix Dell HPE 联想 浪潮 远程桌面 ruoyi fpga开发 Linux awk awk函数 awk结构 awk内置变量 awk参数 awk脚本 awk详解 测试工具 测试用例 功能测试 编辑器 ecmascript KVM 缓存 灵办AI AI写作 AI作画 react next.js 部署next.js kvm QQ 聊天室 asp.net大文件上传 asp.net大文件上传源码 ASP.NET断点续传 asp.net上传文件夹 asp.net上传大文件 .net core断点续传 .net mvc断点续传 firewalld virtualenv 思科模拟器 思科 Cisco 机器人 kubernetes nuxt3 muduo 图形化界面 服务器管理 宝塔面板 配置教程 服务器安装 网站管理 其他 wireshark 剧本 GCC crosstool-ng ue4 着色器 ue5 虚幻 博客 目标跟踪 OpenVINO 推理应用 sql KingBase 开机自启动 wsl2 wsl Reactor 设计模式 C++ 漏洞 kind 微信开放平台 微信公众平台 微信公众号配置 安全威胁分析 多层架构 解耦 vscode 1.86 grafana IPMI unix bot Docker 网站搭建 serv00 k8s 分析解读 弹性计算 云服务器 裸金属服务器 弹性裸金属服务器 虚拟化 express p2p unity3d 银河麒麟 kylin v10 麒麟 v10 spring 网络穿透 Nuxt.js SSH Xterminal 远程连接 系统安全 图像处理 CPU 主板 电源 网卡 postman mock mock server 模拟服务器 mock服务器 Postman内置变量 Postman随机数据 okhttp CORS 跨域 进程信号 CLion IDE 边缘计算 智能硬件 小艺 Pura X micropython esp32 mqtt curl wget 并查集 leetcode IIS服务器 IIS性能 日志监控 服务器繁忙 能力提升 面试宝典 技术 IT信息化 protobuf 序列化和反序列化 安装 MacMini Mac 迷你主机 mini Apple 半虚拟化 硬件虚拟化 Hypervisor webstorm 计算机 git 田俊楠 强制清理 强制删除 mac废纸篓 linux 命令 sed 命令 华为od sqlite dubbo RoboVLM 通用机器人策略 VLA设计哲学 vlm fot robot 视觉语言动作模型 具身智能 MS Materials openssl 密码学 gateway Clion Nova ResharperC++引擎 Centos7 远程开发 业界资讯 模拟退火算法 devops springboot 游戏程序 ios 设置代理 实用教程 code-server MQTT mosquitto 消息队列 r语言 数据可视化 数据分析 pgpool echarts 信息可视化 网页设计 VR手套 数据手套 动捕手套 动捕数据手套 数据库系统 SSH 服务 SSH Server OpenSSH Server ragflow Ark-TS语言 kafka hibernate jar gradle kamailio sip VoIP C# MQTTS 双向认证 emqx 统信 国产操作系统 虚拟机安装 框架搭建 3d 数学建模 minicom 串口调试工具 蓝耘科技 元生代平台工作流 ComfyUI W5500 OLED u8g2 TCP服务器 chfs ubuntu 16.04 命名管道 客户端与服务端通信 remote-ssh rust腐蚀 av1 电视盒子 机顶盒ROM 魔百盒刷机 VMware安装mocOS VMware macOS系统安装 docker命令大全 gcc 低代码 ArcTS 登录 ArcUI GridItem 5G 3GPP 卫星通信 arkUI 程序人生 vSphere vCenter 软件定义数据中心 sddc RTMP 应用层 指令 mq 雨云 NPS chrome devtools selenium chromedriver 孤岛惊魂4 OD机试真题 华为OD机试真题 服务器能耗统计 恒源云 传统数据库升级 银行 大语言模型 LLMs IPMITOOL BMC 硬件管理 opcua opcda KEPServer安装 oneapi 虚拟机 大模型微调 open webui 系统开发 binder 车载系统 framework 源码环境 Cursor 服务器数据恢复 数据恢复 存储数据恢复 北亚数据恢复 oracle数据恢复 elasticsearch dba Docker Hub docker pull 镜像源 daemon.json Ubuntu 24 常用命令 Ubuntu 24 Ubuntu vi 异常处理 pdf VSCode 华为认证 网络工程师 多线程服务器 Linux网络编程 移动云 android studio springsecurity6 oauth2 授权服务器 token sas FTP 服务器 XCC Lenovo Linux PID 繁忙 解决办法 替代网站 汇总推荐 AI推理 服务器部署ai模型 WebUI DeepSeek V3 SSL 域名 pygame 小游戏 五子棋 rsyslog Anolis nginx安装 环境安装 linux插件下载 爬虫 数据集 list raid5数据恢复 磁盘阵列数据恢复 skynet 大模型面经 大模型学习 visualstudio 硬件工程 嵌入式实习 nvidia efficientVIT YOLOv8替换主干网络 TOLOv8 软件工程 AI 原生集成开发环境 Trae AI EasyConnect Cline nextjs reactjs 混合开发 JDK RustDesk自建服务器 rustdesk服务器 docker rustdesk 黑客技术 流式接口 pyqt 蓝桥杯 Kylin-Server VMware安装Ubuntu Ubuntu安装k8s mysql离线安装 ubuntu22.04 mysql8.0 ux 多线程 Google pay Apple pay 服务器主板 AI芯片 open Euler dde gpt 交互 hadoop centos-root /dev/mapper yum clean all df -h / du -sh 网工 opensearch helm 搜索引擎 ssrf 失效的访问控制 命令行 基础入门 编程 WebRTC openwrt Redis Desktop adobe Python 网络编程 聊天服务器 套接字 TCP 客户端 Socket k8s集群资源管理 云原生开发 xrdp string模拟实现 深拷贝 浅拷贝 经典的string类问题 三个swap TrinityCore 魔兽世界 Ubuntu 24.04.1 轻量级服务器 NFS redhat ros2 moveit 机器人运动 eureka 雨云服务器 selete 高级IO 环境迁移 向日葵 技能大赛 崖山数据库 YashanDB 源码剖析 rtsp实现步骤 流媒体开发 直播推流 linux环境变量 飞牛NAS 飞牛OS MacBook Pro 毕设 cnn 相差8小时 UTC 时间 sqlite3 netty Ubuntu Server Ubuntu 22.04.5 银河麒麟操作系统 国产化 rpc 远程过程调用 Windows环境 eNSP 网络规划 VLAN 企业网络 显示过滤器 ICMP Wireshark安装 ci/cd safari 系统 ipython 串口服务器 k8s资源监控 annotations自动化 自动化监控 监控service 监控jvm 安装教程 GPU环境配置 Ubuntu22 CUDA PyTorch Anaconda安装 无桌面 gitea 媒体 risc-v bootstrap web Docker Compose docker-compose css visual studio code Invalid Host allowedHosts vue c/c++ 串口 互信 c camera Arduino 电子信息 Typore 上传视频至服务器代码 vue3批量上传多个视频并预览 如何实现将本地视频上传到网页 element plu视频上传 ant design vue vue3本地上传视频及预览移除 nac 802.1 portal tailscale derp derper 中转 triton 模型分析 矩阵 线性代数 电商平台 大文件分片上传断点续传及进度条 如何批量上传超大文件并显示进度 axios大文件切片上传详细教 node服务器合并切片 vue3大文件上传报错提示错误 大文件秒传跨域报错cors IDEA C++软件实战问题排查经验分享 0xfeeefeee 0xcdcdcdcd 动态库加载失败 程序启动失败 程序运行权限 标准用户权限与管理员权限 iphone elk Logstash 日志采集 无人机 聚类 Unity Dedicated Server Host Client 无头主机 lua vue-i18n 国际化多语言 vue2中英文切换详细教程 如何动态加载i18n语言包 把语言json放到服务器调用 前端调用api获取语言配置文件 网络攻击模型 用户缓冲区 模拟实现 cursor MCP server C/S windows日志 支付 微信支付 开放平台 EtherCAT转Modbus ECT转Modbus协议 EtherCAT转485网关 ECT转Modbus串口网关 EtherCAT转485协议 ECT转Modbus网关 ROS 自动驾驶 DOIT 四博智联 音乐库 群晖 飞牛 prompt 网络结构图 yaml Ultralytics 可视化 H3C 实时互动 mamba 安防软件 端口测试 Linux环境 常用命令 文本命令 目录命令 SenseVoice thingsboard 中间件 可信计算技术 安全架构 显卡驱动 版本 大模型应用 OpenSSH 深度求索 私域 知识库 交叉编译 前后端分离 信号处理 Kali 渗透 gpt-3 文心一言 MacOS录屏软件 midjourney 服务器无法访问 ip地址无法访问 无法访问宝塔面板 宝塔面板打不开 Vmamba bug arm 网络用户购物行为分析可视化平台 大数据毕业设计 FunASR ASR 佛山戴尔服务器维修 佛山三水服务器维修 file server http server web server CH340 串口驱动 CH341 uart 485 序列化反序列化 Jellyfin IPv4 子网掩码 公网IP 私有IP 匿名管道 主从复制 vpn frp 人工智能生成内容 王者荣耀 Ubuntu22.04 开发人员主页 Wi-Fi Linux的基础指令 trea idea ArkTs ArkUI Spring Security 我的世界 我的世界联机 数码 Cookie composer 超融合 bcompare Beyond Compare 模拟器 教程 rdp 实验 技术共享 我的世界服务器搭建 Ubuntu共享文件夹 共享目录 Linux共享文件夹 ruby SysBench 基准测试 鲲鹏 昇腾 npu P2P HDLC eclipse ui 双系统 GRUB引导 Linux技巧 ISO镜像作为本地源 游戏开发 执法记录仪 智能安全帽 smarteye 云电竞 云电脑 todesk Mac内存不够用怎么办 MNN Qwen linux安装配置 备份SQL Server数据库 数据库备份 傲梅企业备份网络版 kali 共享文件夹 uv 键盘 glibc 嵌入式Linux IPC EMUI 回退 降级 升级 dns是什么 如何设置电脑dns dns应该如何设置 apt xss 在线预览 xlsx xls文件 在浏览器直接打开解析xls表格 前端实现vue3打开excel 文件地址url或接口文档流二进 IO模型 软负载 AI-native Docker Desktop pppoe radius gaussdb rnn IM即时通讯 剪切板对通 HTML FORMAT 链表 saltstack n8n 工作流 workflow ocr AI agent 云服务 单元测试 算力 seatunnel edge浏览器 g++ g++13 Radius npm uni-file-picker 拍摄从相册选择 uni.uploadFile H5上传图片 微信小程序上传图片 qt项目 qt项目实战 qt教程 arcgis 国标28181 视频监控 监控接入 语音广播 流程 SIP SDP 远程服务 trae clickhouse Portainer搭建 Portainer使用 Portainer使用详解 Portainer详解 Portainer portainer 社交电子 高效远程协作 TrustViewer体验 跨设备操作便利 智能远程控制 IMX317 MIPI H265 VCU pyautogui EMQX 通信协议 VS Code 稳定性 看门狗 计算虚拟化 弹性裸金属 工业4.0 运维监控 tensorflow windwos防火墙 defender防火墙 win防火墙白名单 防火墙白名单效果 防火墙只允许指定应用上网 防火墙允许指定上网其它禁止 线程 less 显示管理器 lightdm gdm 远程登录 telnet 同步 备份 建站 代理 阻塞队列 生产者消费者模型 服务器崩坏原因 小番茄C盘清理 便捷易用C盘清理工具 小番茄C盘清理的优势尽显何处？ 教你深度体验小番茄C盘清理 C盘变红？！不知所措？ C盘瘦身后电脑会发生什么变化？ laravel Linux无人智慧超市 LInux多线程服务器 QT项目 LInux项目 单片机项目 小智AI服务端 xiaozhi TTS 直流充电桩 充电桩 junit AD 域 域管理 宝塔 DeepSeek r1 Open WebUI cd 目录切换 OpenManus minecraft 备选 网站 api 调用 示例 银河麒麟桌面操作系统 Kylin OS AD域 游戏引擎 反向代理 致远OA OA服务器 服务器磁盘扩容 策略模式 单例模式 自学笔记 小米 澎湃OS Android SWAT 配置文件 服务管理 网络共享 游戏机 miniapp 真机调试 调试 debug 断点 网络API请求调试方法 国内源 Netty 即时通信 NIO 毕昇JDK tcp HTTP 服务器控制 ESP32 DeepSeek vasp安装 查询数据库服务IP地址 SQL Server 语音识别 AutoDL bat 分布式训练 宠物 毕业设计 免费学习 宠物领养 宠物平台 Ubuntu DeepSeek DeepSeek Ubuntu DeepSeek 本地部署 DeepSeek 知识库 DeepSeek 私有化知识库 本地部署 DeepSeek DeepSeek 私有化部署 EtherNet/IP串口网关 EIP转RS485 EIP转Modbus EtherNet/IP网关协议 EIP转RS485网关 EIP串口服务器 xml 根服务器 华为机试 权限 AISphereButler outlook 自动化任务管理 银河麒麟高级服务器 外接硬盘 Kylin easyui langchain 程序员创富 flink fd 文件描述符 回显服务器 UDP的API使用 飞牛nas fnos 做raid 装系统 Java Applet URL操作 服务器建立 Socket编程 网络文件读取 大模型入门 大模型教程 log4j 虚拟显示器 远程控制 7z yum源切换 更换国内yum源 cmos 输入法 ukui 麒麟kylinos openeuler 需求分析 规格说明书 keepalived ros sonoma 自动更新 重启 排查 系统重启 日志 原因 xshell termius iterm2 vr neo4j 数据仓库 数据库开发 database ftp 火绒安全 CVE-2024-7347 rustdesk VPS 内网服务器 内网代理 内网通信 VM搭建win2012 win2012应急响应靶机搭建 攻击者获取服务器权限 上传wakaung病毒 应急响应并溯源 挖矿病毒处置 应急响应综合性靶场 服务网格 istio DocFlow dns big data 飞书 免费域名 域名解析 uniapp web3 xcode Linux的权限 怎么卸载MySQL MySQL怎么卸载干净 MySQL卸载重新安装教程 MySQL5.7卸载 Linux卸载MySQL8.0 如何卸载MySQL教程 MySQL卸载与安装 单一职责原则 LInux 软件构建 asp.net大文件上传下载 影刀 #影刀RPA# iis 监控k8s 监控kubernetes 语法 spark HistoryServer Spark YARN jobhistory CDN Headless Linux 本地部署AI大模型 nfs 黑苹果 embedding sdkman 实习 Claude 自定义客户端 SAS 僵尸世界大战 游戏服务器搭建 AnythingLLM AnythingLLM安装 图形渲染 zookeeper 阿里云ECS 流水线 脚本式流水线 LORA NLP DenseNet v10 软件 ldap armbian u-boot CrewAI qemu libvirt alias unalias 别名 WebVM 源码 banner regedit 开机启动 can 线程池 GoogLeNet URL 项目部署到linux服务器 项目部署过程 本地部署 hive Hive环境搭建 hive3环境 Hive远程模式 vscode1.86 1.86版本 ssh远程连接 SSE webgl LLM Web APP Streamlit linux上传下载 cpp-httplib 京东云 迁移指南 USB网络共享 MI300x 监控k8s集群 集群内prometheus 开发环境 SSL证书 sysctl.conf vm.nr_hugepages 自动化编程 ssh漏洞 ssh9.9p2 CVE-2025-23419 flash-attention SRS 流媒体 直播 docker run 数据卷挂载 交互模式 vmware 卡死 视觉检测 rclone AList webdav fnOS 文件分享 VMware创建虚拟机 性能测试 RAGFlow 本地知识库部署 DeepSeek R1 模型 etl odoo 服务器动作 Server action epoll ai小智 语音助手 ai小智配网 ai小智教程 esp32语音助手 diy语音助手 tidb GLIBC lsb_release /etc/issue /proc/version uname -r 查看ubuntu版本 python3.11 视频编解码 移动魔百盒 代码托管服务 matplotlib USB转串口 高效日志打印 串口通信日志 服务器日志 系统状态监控日志 异常记录日志 邮件APP 免费软件 远程看看 远程协助 sentinel DBeaver kerberos wordpress 无法访问wordpess后台 打开网站页面错乱 linux宝塔面板 wordpress更换服务器 历史版本 下载 swoole 三级等保 服务器审计日志备份 实战案例 FTP服务器 perf rime 干货分享 黑客工具 密码爆破 cfssl 架构与原理 软考 产测工具框架 IMX6ULL 管理框架 联想开天P90Z装win10 多个客户端访问 IO多路复用 TCP相关API openstack Xen 粘包问题 ranger MySQL8.0 milvus 流量运营 QT 5.12.12 QT开发环境 Ubuntu18.04 健康医疗 互联网医院 KylinV10 麒麟操作系统 Vmware iBMC UltraISO 防火墙 NAT转发 NAT Server 程序 性能分析 镜像 MVS 海康威视相机 aarch64 编译安装 HPC Deepseek-R1 私有化部署 推理模型 PX4 强化学习 proxy模式 树莓派 VNC navicat 虚拟局域网 cocoapods 域名服务 DHCP 符号链接 配置 onlyoffice 在线office yolov8 Attention Unity插件 iventoy VmWare OpenEuler css3 kernel 浏览器自动化 容器技术 jina SSH 密钥生成 SSH 公钥 私钥 生成 云桌面 微软 AD域控 证书服务器 TrueLicense seleium 加解密 Yakit yaklang UDP MacOS docker搭建pg docker搭建pgsql pg授权 postgresql使用 postgresql搭建 iperf3 带宽测试 带外管理 对比 工具 meld DiffMerge grub 版本升级 扩容 开发 服务器时间 wps 大模型推理 lio-sam SLAM 项目部署 推荐算法 gnu ubuntu24.04.1 代理服务器 中兴光猫 换光猫 网络桥接 自己换光猫 llama.cpp 多端开发 智慧分发 应用生态 鸿蒙OS Node-Red 编程工具 流编程 嵌入式系统开发 su sudo fast 端口 查看 ss deployment daemonset statefulset cronjob 读写锁 AI Agent 字节智能运维 办公自动化 自动化生成 pdf教程 状态模式 个人博客 元服务 应用上架 换源 Debian 云耀服务器 rtsp服务器 rtsp server android rtsp服务 安卓rtsp服务器 移动端rtsp服务 大牛直播SDK x64 SIGSEGV xmm0 ShenTong HAProxy rag ragflow 源码启动 大模型部署 物联网开发 Linux find grep 钉钉 查看显卡进程 fuser ArtTS hexo 端口聚合 windows11 deekseek SEO 抓包工具 System V共享内存 进程通信 磁盘镜像 服务器镜像 服务器实时复制 实时文件备份 极限编程 网络建设与运维 CentOS NLP模型 HiCar CarLife+ CarPlay QT RK3588 信号 docker desktop image xpath定位元素 word Windows MDK 嵌入式开发工具 论文笔记 sublime text SVN Server tortoise svn deep learning docker部署翻译组件 docker部署deepl docker搭建deepl java对接deepl 翻译组件使用 nlp ABAP 相机 企业网络规划 华为eNSP hosts nvm whistle 存储维护 NetApp存储 EMC存储 Xinference 金仓数据库 2025 征文 数据库平替用金仓 autodl HarmonyOS NEXT 原生鸿蒙 合成模型 扩散模型 图像生成 fstab perl 李心怡 IMM 智能音箱 智能家居 HarmonyOS OpenHarmony wpf 鸿蒙开发 移动开发 Python基础 Python教程 Python技巧 WLAN react native 基础环境 sequoiaDB wsgiref Web 服务器网关接口 AP配网 AK配网 小程序AP配网和AK配网教程 WIFI设备配网小程序UDP开 捆绑 链接 谷歌浏览器 youtube google gmail zip unzip Qwen2.5-VL vllm 软链接 硬链接 网络爬虫 ardunio BLE prometheus数据采集 prometheus数据模型 prometheus特点 大大通 第三代半导体 碳化硅 ai工具 java-rocketmq figma GIS 遥感 WebGIS 内网环境 h.264 ssh远程登录 top Linux top top命令详解 top命令重点 top常用参数 虚幻引擎 virtualbox 本地化部署 网卡的名称修改 eth0 ens33 win服务器架设 windows server 问题解决 ubuntu24 vivado24 考研 网络药理学 生信 gromacs 分子动力学模拟 MD 动力学模拟 ubuntu20.04 ros1 Noetic 20.04 apt 安装 kotlin chrome 浏览器下载 chrome 下载安装 谷歌浏览器下载 私有化 浏览器开发 AI浏览器 玩机技巧 软件分享 软件图标 dash 正则表达式 DIFY db 烟花代码 烟花 元旦 性能调优 安全代理 MySql 信创 信创终端 中科方德 harmonyOS面试题 磁盘清理 软件卸载 系统清理 powerpoint 环境配置 dity make UOS1070e 知识图谱 searxng PPI String Cytoscape CytoHubba Docker引擎已经停止 Docker无法使用 WSL进度一直是0 镜像加速地址 TCP协议 抗锯齿 拓扑图 visual studio deepseek r1 firewall 欧标 OCPP dock 加速 Linux权限 权限命令 特殊权限 WSL2 上安装 Ubuntu vu大文件秒传跨域报错cors MAVROS 四旋翼无人机 conda配置 conda镜像源 k8s二次开发 集群管理 rpa 上传视频文件到服务器 uniApp本地上传视频并预览 uniapp移动端h5网页 uniapp微信小程序上传视频 uniapp app端视频上传 uniapp uview组件库 达梦 DM8 安装MySQL 通信工程 毕业 热榜 风扇控制软件 接口优化 数字证书 签署证书 离线部署dify mm-wiki搭建 linux搭建mm-wiki mm-wiki搭建与使用 mm-wiki使用 mm-wiki详解 智能电视 库 解决方案 macOS js 服务器正确解析请求体 AI员工 西门子PLC 通讯 IO docker部署Python 沙盒 yum换源 CentOS Stream 开机黑屏 计算生物学 生物信息 基因组 nosql 英语 增强现实 沉浸式体验 应用场景 技术实现 案例分析 AR 搜狗输入法 中文输入法 MobaXterm 论文阅读 Sealos rancher 网络搭建 神州数码 神州数码云平台 云平台 搭建个人相关服务器 yolov5 ip协议 多路转接

VPS345，全球数据中心基础服务供应商，APNIC 和 ARIN 会员单位，自有 ASN、IPv4、IPv6 及自营 SonderCloud 云数据中心。

服务器租用

站群服务器

高防服务器

关于我们

Copyright © 2014-2025 VPS345.com 保留所有权利 皖ICP备16015960号-5 网站地图