Linux C语言线程创建的并发限制
2021-01-233.8k 阅读
Linux C 语言线程创建的并发限制概述
在 Linux 环境下使用 C 语言进行多线程编程时，线程创建的并发限制是一个需要深入理解的重要概念。多线程编程旨在利用多核处理器的优势，提高程序的执行效率，然而实际应用中，线程的并发创建并非毫无限制。这一限制受到多种因素的影响，包括系统资源、内核参数以及硬件特性等。
资源限制对线程创建并发数的影响
- 内存资源
- 每个线程在创建时都需要占用一定的内存空间。线程栈是其中重要的一部分，它用于存储线程函数的局部变量、函数调用的参数和返回地址等。在 Linux 系统中，默认的线程栈大小通常是 8MB（不同系统可能有所差异，可以通过
ulimit -s命令查看）。假设系统的可用内存为有限值，例如 1GB，且不考虑其他进程占用内存的情况下，简单计算可得理论上能够创建的线程数大约为1024MB / 8MB = 128个（这里仅是理论值，实际情况因系统开销等因素会更少）。 - 除了线程栈，线程控制块（TCB）也需要占用内存空间。TCB 用于存储线程的状态、优先级等信息。虽然单个 TCB 占用内存相对较小，但当大量线程并发创建时，其占用的内存总和也不容忽视。
- 以下是一个简单的示例代码，展示线程栈大小对线程创建数量的影响：
- 每个线程在创建时都需要占用一定的内存空间。线程栈是其中重要的一部分，它用于存储线程函数的局部变量、函数调用的参数和返回地址等。在 Linux 系统中，默认的线程栈大小通常是 8MB（不同系统可能有所差异，可以通过
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 1024 * 1024 // 1MB 线程栈大小
void* thread_function(void* arg) {
// 线程函数简单执行一些操作
return NULL;
}
int main() {
pthread_t threads[1000];
pthread_attr_t attr;
int i, ret;
void* status;
// 初始化线程属性
pthread_attr_init(&attr);
// 设置线程栈大小
pthread_attr_setstacksize(&attr, STACK_SIZE);
for (i = 0; i < 1000; i++) {
ret = pthread_create(&threads[i], &attr, thread_function, NULL);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
break;
}
}
// 等待所有线程结束
for (i = 0; i < 1000; i++) {
pthread_join(threads[i], &status);
}
// 销毁线程属性
pthread_attr_destroy(&attr);
return 0;
}
在上述代码中，通过 pthread_attr_setstacksize 函数设置线程栈大小为 1MB。运行该程序时，可以观察到随着线程创建数量的增加，最终会因为内存不足导致线程创建失败。
2. 文件描述符资源
- 在 Linux 系统中，每个线程都可能需要使用文件描述符，例如打开文件、网络套接字等。系统对文件描述符的数量是有限制的，可以通过 ulimit -n 命令查看。默认情况下，这个限制可能相对较小，例如 1024。当大量线程并发创建并尝试使用文件描述符时，很容易达到这个限制。
- 当达到文件描述符限制时，新线程如果需要创建文件描述符相关的资源（如打开文件或创建套接字），将会失败，返回 EMFILE 错误。以下代码展示了文件描述符限制对线程创建的影响：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
void* thread_function(void* arg) {
int fd = open("/dev/null", O_RDONLY);
if (fd == -1) {
perror("打开文件失败");
}
// 这里简单处理，实际应用中可能需要更复杂的操作
close(fd);
return NULL;
}
int main() {
pthread_t threads[1000];
int i, ret;
void* status;
for (i = 0; i < 1000; i++) {
ret = pthread_create(&threads[i], NULL, thread_function, NULL);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
break;
}
}
// 等待所有线程结束
for (i = 0; i < 1000; i++) {
pthread_join(threads[i], &status);
}
return 0;
}
在这个示例中，每个线程尝试打开 /dev/null 文件获取一个文件描述符。运行该程序时，随着线程的创建，当达到文件描述符限制时，新线程中的 open 操作会失败，进而可能影响线程的正常运行或导致线程创建失败。
内核参数对线程创建并发数的影响
kernel.pid_max参数- 在 Linux 系统中，
kernel.pid_max内核参数定义了系统中进程 ID（PID）的最大值。虽然线程在 Linux 中是轻量级进程，但也会占用 PID 资源。默认情况下，kernel.pid_max的值通常为 32768。这意味着系统最多可以有 32768 个进程或线程（实际上由于系统进程等占用，可用于用户线程的数量更少）。 - 可以通过修改
/proc/sys/kernel/pid_max文件来调整这个参数的值。例如，要将kernel.pid_max设置为 65536，可以使用以下命令：
- 在 Linux 系统中，
echo 65536 | sudo tee /proc/sys/kernel/pid_max
kernel.threads-max参数kernel.threads-max内核参数直接限制了系统范围内可以创建的线程总数。这个值是根据系统内存等资源动态计算的，但也可以手动调整。其计算公式大致为threads-max = (total_memory - reserved_memory) / (thread_stack_size + other_overhead)，其中total_memory是系统总内存，reserved_memory是系统保留的内存，thread_stack_size是线程栈大小，other_overhead包括 TCB 等其他开销。- 要查看当前
kernel.threads-max的值，可以使用以下命令：
cat /proc/sys/kernel/threads-max
要修改这个值，可以编辑 /etc/sysctl.conf 文件，添加或修改以下行：
kernel.threads-max = <new_value>
然后执行 sudo sysctl -p 使修改生效。
硬件特性对线程创建并发数的影响
- CPU 核心数
- CPU 核心数是影响线程并发执行效率的重要硬件因素。虽然理论上可以创建大量线程，但实际能够同时执行的线程数量受到 CPU 核心数的限制。例如，一个 4 核的 CPU，在理想情况下最多可以同时执行 4 个线程（不考虑超线程技术）。如果创建的线程数远远超过 CPU 核心数，操作系统需要通过时间片轮转等调度算法来分配 CPU 时间给各个线程，这会增加线程上下文切换的开销。
- 过多的上下文切换会导致系统性能下降，因为每次上下文切换都需要保存和恢复线程的寄存器状态、内存映射等信息。以下代码通过模拟线程执行任务，展示 CPU 核心数对多线程性能的影响：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysinfo.h>
#define THREADS 100
#define TASK_ITERATIONS 100000000
void* thread_function(void* arg) {
long long i;
for (i = 0; i < TASK_ITERATIONS; i++) {
// 简单的计算任务
volatile int a = 1 + 2;
}
return NULL;
}
int main() {
pthread_t threads[THREADS];
int i, ret;
void* status;
struct sysinfo info;
sysinfo(&info);
printf("系统 CPU 核心数: %d\n", info.nr_cpu_ids);
for (i = 0; i < THREADS; i++) {
ret = pthread_create(&threads[i], NULL, thread_function, NULL);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
break;
}
}
// 等待所有线程结束
for (i = 0; i < THREADS; i++) {
pthread_join(threads[i], &status);
}
return 0;
}
在上述代码中，通过 sysinfo 函数获取系统的 CPU 核心数。每个线程执行一个简单的计算任务，通过运行该程序并观察执行时间，可以发现当线程数远超过 CPU 核心数时，程序执行时间会显著增加，这是由于上下文切换开销增大导致的。
2. 缓存大小
- CPU 缓存分为一级缓存（L1）、二级缓存（L2）和三级缓存（L3）。缓存用于存储 CPU 频繁访问的数据和指令，以提高访问速度。当多线程并发执行时，如果线程的数据和指令频繁竞争缓存空间，会导致缓存命中率下降，从而降低系统性能。
- 例如，两个线程频繁访问的数据不在同一个缓存行（cache line）中，就会导致缓存颠簸（cache thrashing）。缓存颠簸会使得 CPU 花费更多时间从内存中获取数据，而不是从高速缓存中获取，进而影响线程的执行效率。虽然缓存大小对线程创建的并发数量没有直接限制，但会影响多线程程序的整体性能，间接影响实际有效的并发线程数。
处理线程创建并发限制的策略
优化资源使用
- 合理设置线程栈大小
- 根据线程的实际需求，合理调整线程栈大小。对于一些简单的线程，可能不需要默认的 8MB 线程栈。例如，如果线程只执行一些简单的计算任务，没有大量的局部变量或递归调用，可以将线程栈大小设置得较小。通过
pthread_attr_setstacksize函数可以实现这一点。 - 以下是一个根据任务需求调整线程栈大小的示例：
- 根据线程的实际需求，合理调整线程栈大小。对于一些简单的线程，可能不需要默认的 8MB 线程栈。例如，如果线程只执行一些简单的计算任务，没有大量的局部变量或递归调用，可以将线程栈大小设置得较小。通过
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define SMALL_STACK_SIZE 256 * 1024 // 256KB 线程栈大小
void* simple_task(void* arg) {
int a = 10;
// 简单计算任务
int result = a * a;
return NULL;
}
int main() {
pthread_t thread;
pthread_attr_t attr;
int ret;
void* status;
// 初始化线程属性
pthread_attr_init(&attr);
// 设置较小的线程栈大小
pthread_attr_setstacksize(&attr, SMALL_STACK_SIZE);
ret = pthread_create(&thread, &attr, simple_task, NULL);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
return 1;
}
// 等待线程结束
pthread_join(thread, &status);
// 销毁线程属性
pthread_attr_destroy(&attr);
return 0;
}
在这个示例中，对于执行简单计算任务的线程，将线程栈大小设置为 256KB，减少了内存占用，从而可以在相同内存条件下创建更多的线程。 2. 有效管理文件描述符 - 在多线程程序中，尽量复用文件描述符，避免每个线程都独立打开相同的文件或创建重复的套接字。例如，可以将文件描述符作为参数传递给线程函数，让多个线程共享该文件描述符进行操作。 - 以下是一个多线程共享文件描述符的示例：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
struct FileInfo {
int fd;
// 其他可能需要传递给线程的文件相关信息
};
void* thread_function(void* arg) {
struct FileInfo* file_info = (struct FileInfo*)arg;
int fd = file_info->fd;
// 线程对文件进行操作，例如读取文件内容
char buffer[1024];
ssize_t read_bytes = read(fd, buffer, sizeof(buffer));
if (read_bytes == -1) {
perror("读取文件失败");
}
return NULL;
}
int main() {
pthread_t threads[10];
struct FileInfo file_info;
int i, ret;
void* status;
file_info.fd = open("/etc/passwd", O_RDONLY);
if (file_info.fd == -1) {
perror("打开文件失败");
return 1;
}
for (i = 0; i < 10; i++) {
ret = pthread_create(&threads[i], NULL, thread_function, &file_info);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
break;
}
}
// 等待所有线程结束
for (i = 0; i < 10; i++) {
pthread_join(threads[i], &status);
}
close(file_info.fd);
return 0;
}
在上述代码中，主线程打开文件获取文件描述符，然后将包含文件描述符的结构体传递给多个线程，实现文件描述符的共享，减少文件描述符资源的占用。
调整内核参数
- 根据需求调整
kernel.pid_max- 如果确定需要创建大量线程，且系统资源允许，可以适当增大
kernel.pid_max的值。但需要注意，过大的值可能会导致系统资源消耗过多，影响系统的稳定性。在调整之前，需要对系统的负载和资源使用情况进行充分评估。 - 例如，对于一些高性能计算集群，可能需要处理大量的并发任务，每个任务可能对应一个线程。在这种情况下，可以适当增大
kernel.pid_max值，以满足线程创建的需求。
- 如果确定需要创建大量线程，且系统资源允许，可以适当增大
- 合理设置
kernel.threads-max- 根据系统的内存配置和实际线程创建需求，合理调整
kernel.threads-max。如果系统内存充足，且需要创建大量线程，可以适当增大该值。但同样需要注意，过高的值可能会导致系统内存耗尽等问题。 - 例如，在一个专门用于数据处理的服务器上，已知系统内存为 32GB，且每个线程栈大小设置为 4MB，通过计算可以适当调整
kernel.threads-max值，以充分利用系统内存资源创建更多线程。
- 根据系统的内存配置和实际线程创建需求，合理调整
基于硬件特性的优化
- 线程数与 CPU 核心数匹配
- 根据 CPU 核心数来确定合适的线程数。一般来说，线程数可以设置为 CPU 核心数的倍数，但不宜过大。例如，对于一个 8 核的 CPU，可以将线程数设置为 16 或 32，通过实验和性能测试来确定最优值。这样可以在充分利用 CPU 资源的同时，避免过多的上下文切换开销。
- 以下代码展示了根据 CPU 核心数动态创建线程的示例：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysinfo.h>
void* task(void* arg) {
// 简单任务，例如模拟数据处理
return NULL;
}
int main() {
struct sysinfo info;
sysinfo(&info);
int num_cores = info.nr_cpu_ids;
pthread_t threads[num_cores * 2];
int i, ret;
void* status;
for (i = 0; i < num_cores * 2; i++) {
ret = pthread_create(&threads[i], NULL, task, NULL);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
break;
}
}
// 等待所有线程结束
for (i = 0; i < num_cores * 2; i++) {
pthread_join(threads[i], &status);
}
return 0;
}
在这个示例中，通过 sysinfo 函数获取 CPU 核心数，然后创建 CPU 核心数两倍的线程，通过实际运行和性能测试可以进一步优化线程数量。
2. 减少缓存竞争
- 在设计多线程程序时，尽量将相关的数据和操作放在同一个线程中，避免不同线程频繁访问相同的缓存行。例如，对于一些共享数据结构，可以采用无锁数据结构或对数据进行合理分区，使得不同线程访问不同的数据分区，减少缓存竞争。
- 以下是一个简单的无锁数据结构示例，用于减少缓存竞争：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdatomic.h>
atomic_int shared_value;
void* thread_function(void* arg) {
// 无锁操作共享值
atomic_fetch_add(&shared_value, 1);
return NULL;
}
int main() {
pthread_t threads[10];
int i, ret;
void* status;
atomic_init(&shared_value, 0);
for (i = 0; i < 10; i++) {
ret = pthread_create(&threads[i], NULL, thread_function, NULL);
if (ret != 0) {
printf("线程创建失败: %d\n", ret);
break;
}
}
// 等待所有线程结束
for (i = 0; i < 10; i++) {
pthread_join(threads[i], &status);
}
printf("最终共享值: %d\n", atomic_load(&shared_value));
return 0;
}
在这个示例中，使用 atomic_int 类型实现无锁操作，减少了线程间对共享数据的竞争，从而降低缓存竞争的可能性，提高多线程程序的性能。
实际案例分析
案例一：Web 服务器多线程模型
- 场景描述
- 假设有一个基于 Linux 的 Web 服务器，使用 C 语言和多线程技术开发。该服务器需要处理大量的并发 HTTP 请求，每个请求由一个线程处理。服务器运行在一台具有 16GB 内存、8 核 CPU 的服务器上。
- 遇到的问题
- 在高并发情况下，服务器开始出现线程创建失败的情况，导致部分请求无法及时处理。通过分析发现，由于每个线程默认使用 8MB 的线程栈，随着并发请求的增加，内存迅速耗尽，达到了系统的内存限制，从而无法创建新的线程。同时，文件描述符的限制也对线程创建产生了一定影响，因为每个线程在处理 HTTP 请求时可能需要打开文件（如读取 HTML 页面文件）或创建网络套接字。
- 解决方案
- 首先，对线程栈大小进行调整。根据实际请求处理任务的复杂度，将线程栈大小调整为 2MB。通过修改
pthread_attr_setstacksize函数来实现这一调整。这样在相同的 16GB 内存下，理论上可以创建的线程数从16GB / 8MB = 2048个增加到16GB / 2MB = 8192个（实际因系统开销等因素会更少）。 - 其次，优化文件描述符的使用。对于一些常用的文件（如 HTML 模板文件），采用共享文件描述符的方式，由主线程打开文件并将文件描述符传递给工作线程，避免每个线程重复打开文件。同时，对网络套接字的管理进行优化，尽量复用已有的套接字连接，减少新套接字的创建。
- 最后，根据服务器的硬件特性，合理调整线程数。由于服务器是 8 核 CPU，经过性能测试，将线程数设置为 32 个时，服务器的性能最佳。这样既充分利用了 CPU 资源，又避免了过多的上下文切换开销。
- 首先，对线程栈大小进行调整。根据实际请求处理任务的复杂度，将线程栈大小调整为 2MB。通过修改
案例二：科学计算程序多线程优化
- 场景描述
- 一个科学计算程序，用于处理大规模的数值模拟。程序运行在一个集群环境中，每个节点具有 32GB 内存和 16 核 CPU。该程序使用多线程技术并行处理不同的数据块，以提高计算效率。
- 遇到的问题
- 在运行过程中，发现随着线程数的增加，程序的执行效率并没有线性提升，反而在创建一定数量的线程后开始下降。通过分析发现，由于线程数过多，导致 CPU 缓存命中率下降，缓存竞争严重。同时，线程创建数量接近系统的
kernel.threads-max限制，部分线程创建失败。
- 在运行过程中，发现随着线程数的增加，程序的执行效率并没有线性提升，反而在创建一定数量的线程后开始下降。通过分析发现，由于线程数过多，导致 CPU 缓存命中率下降，缓存竞争严重。同时，线程创建数量接近系统的
- 解决方案
- 针对缓存竞争问题，对数据进行分区处理。将大规模的数据划分为多个较小的数据块，每个线程负责处理一个独立的数据块，减少不同线程对相同缓存行的访问。这样可以提高缓存命中率，提升程序的执行效率。
- 对于线程创建限制问题，通过调整
kernel.threads-max参数来满足线程创建的需求。根据节点的内存配置和线程栈大小（设置为 4MB），计算出合理的kernel.threads-max值，并通过修改/etc/sysctl.conf文件进行调整。同时，对线程的任务进行优化，确保每个线程执行的任务足够复杂，以充分利用 CPU 资源，避免过多的轻量级线程导致的资源浪费。
通过以上实际案例分析，可以看出在 Linux C 语言多线程编程中，深入理解线程创建的并发限制，并采取相应的优化策略是提高程序性能和稳定性的关键。无论是 Web 服务器应用还是科学计算程序，都需要根据具体的场景和硬件环境，合理调整资源使用、内核参数以及线程设计，以达到最佳的并发效果。