51CTO首页
AI.x社区
博客
学堂
精品班
直播训练营
企业培训
鸿蒙开发者社区
WOT技术大会
AIGC创新中国行
公众号矩阵
移动端
短视频免费课程课程排行直播课软考学堂
全部课程厂商认证IT技术2024年软考PMP项目管理软考资讯
在线学习
文章资源问答课堂专栏直播
51CTO
鸿蒙开发者社区
51CTO技术栈
51CTO官微
51CTO学堂
51CTO博客
CTO训练营
鸿蒙开发者社区订阅号
51CTO题库小程序
51CTO学堂APP
51CTO学堂企业版APP
鸿蒙开发者社区视频号
账号设置 退出

C语言线程库的使用

作者：佚名
开发 后端
进程是资源分配的最小单位，线程是操作系统调度执行的最小单位。

[[434554]]

一、线程概述

线程是轻量级的进程（LWP：light weight process），在 Linux 环境下线程的本质仍是进程。在计算机上运行的程序是一组指令及指令参数的组合，指令按照既定的逻辑控制计算机运行。操作系统会以进程为单位，分配系统资源，可以这样理解，进程是资源分配的最小单位，线程是操作系统调度执行的最小单位。

先从概念上了解一下线程和进程之间的区别：

    1.  进程有自己独立的地址空间，多个线程共用同一个地址空间

  •  线程更加节省系统资源，效率不仅可以保持的，而且能够更高
  •  在一个地址空间中多个线程独享：每个线程都有属于自己的栈区，寄存器 (内核中管理的)
  •  在一个地址空间中多个线程共享：代码段，堆区，全局数据区，打开的文件 (文件描述符表) 都是线程共享的

    2.  线程是程序的最小执行单位，进程是操作系统中最小的资源分配单位

  •  每个进程对应一个虚拟地址空间，一个进程只能抢一个 CPU 时间片
  •  一个地址空间中可以划分出多个线程，在有效的资源基础上，能够抢更多的 CPU 时间片

    3.  CPU 的调度和切换：线程的上下文切换比进程要快的多

上下文切换：进程 / 线程分时复用 CPU 时间片，在切换之前会将上一个任务的状态进行保存，下次切换回这个任务的时候，加载这个状态继续运行，任务从保存到再次加载这个过程就是一次上下文切换。

    4.  线程更加廉价，启动速度更快，退出也快，对系统资源的冲击小。

在处理多任务程序的时候使用多线程比使用多进程要更有优势，但是线程并不是越多越好，如何控制线程的个数呢？

  1.  文件 IO 操作：文件 IO 对 CPU 是使用率不高，因此可以分时复用 CPU 时间片，线程的个数 = 2 * CPU 核心数 (效率最高)
  2.  处理复杂的算法 (主要是 CPU 进行运算，压力大)，线程的个数 = CPU 的核心数 (效率最高)

二、创建线程

2.1 线程函数

每一个线程都有一个唯一的线程 ID，ID 类型为 pthread_t，这个 ID 是一个无符号长整形数，如果想要得到当前线程的线程 ID，可以调用如下函数： 

  1. pthread_t pthread_self(void); // 返回当前线程的线程ID 

在一个进程中调用线程创建函数，就可得到一个子线程，和进程不同，需要给每一个创建出的线程指定一个处理函数，否则这个线程无法工作。 

  1. #include <pthread.h>  
  2. int pthread_create(pthread_t *thread, const pthread_attr_t *attr,  
  3.                    void *(*start_routine) (void *), void *arg);  
  4. // Compile and link with -pthread, 线程库的名字叫pthread, 全名: libpthread.so libptread.a 

参数:

  •  thread: 传出参数，是无符号长整形数，线程创建成功，会将线程 ID 写入到这个指针指向的内存中
  •  attr: 线程的属性，一般情况下使用默认属性即可，写 NULL
  •  start_routine: 函数指针，创建出的子线程的处理动作，也就是该函数在子线程中执行。
  •  arg: 作为实参传递到 start_routine 指针指向的函数内部

返回值：线程创建成功返回 0，创建失败返回对应的错误号

2.2 创建线程

下面是创建线程的示例代码，在创建过程中一定要保证编写的线程函数与规定的函数指针类型一致：void *(*start_routine) (void *): 

  1. // pthread_create.c   
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <unistd.h>  
  5. #include <string.h>  
  6. #include <pthread.h>  
  7. // 子线程的处理代码  
  8. void* working(void* arg)  
  9. {  
  10.     printf("我是子线程, 线程ID: %ld\n", pthread_self());  
  11.     for(int i=0; i<9; ++i)  
  12.     {  
  13.         printf("child == i: = %d\n", i);  
  14.     }  
  15.     return NULL;  
  16. }  
  17. int main()  
  18. {  
  19.     // 1. 创建一个子线程  
  20.     pthread_t tid;  
  21.     pthread_create(&tid, NULL, working, NULL);  
  22.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  23.     // 2. 子线程不会执行下边的代码, 主线程执行  
  24.     printf("我是主线程, 线程ID: %ld\n", pthread_self());  
  25.     for(int i=0; i<3; ++i)  
  26.     {  
  27.         printf("i = %d\n", i);  
  28.     }  
  29.      // 休息, 休息一会儿...  
  30.     // sleep(1);   
  31.      return 0;  
  32. } 

编译测试程序，会看到如下错误信息： 

  1. $ gcc pthread_create.c   
  2. /tmp/cctkubA6.o: In function `main': 
  3. pthread_create.c:(.text+0x7f): undefined reference to `pthread_create'  
  4. collect2: error: ld returned 1 exit status 

错误原因是因为编译器链接不到线程库文件（动态库），需要在编译的时候通过参数指定出来，动态库名为 libpthread.so 需要使用的参数为 -l，根据规则掐头去尾最终形态应该写成：-lpthread（参数和参数值中间可以有空格）。正确的编译命令为： 

  1. # pthread_create 函数的定义在某一个库中, 编译的时候需要加库名 pthread  
  2. $ gcc pthread_create.c -lpthread  
  3. $ ./a.out   
  4. 子线程创建成功, 线程ID: 139712560109312 
  5. 我是主线程, 线程ID: 139712568477440  
  6. i = 0 
  7. i = 1  
  8. i = 2 

在打印的日志输出中为什么子线程处理函数没有执行完毕呢（只看到了子线程的部分日志输出）？

主线程一直在运行，执行期间创建出了子线程，说明主线程有 CPU 时间片，在这个时间片内将代码执行完毕了，主线程就退出了。子线程被创建出来之后需要抢 cpu 时间片, 抢不到就不能运行，如果主线程退出了, 虚拟地址空间就被释放了, 子线程就一并被销毁了。但是如果某一个子线程退出了, 主线程仍在运行, 虚拟地址空间依旧存在。

得到的结论：在没有人为干预的情况下，虚拟地址空间的生命周期和主线程是一样的，与子线程无关。

目前的解决方案：让子线程执行完毕，主线程再退出，可以在主线程中添加挂起函数 sleep();

三、线程退出

在编写多线程程序的时候，如果想要让线程退出，但是不会导致虚拟地址空间的释放（针对于主线程），我们就可以调用线程库中的线程退出函数，只要调用该函数当前线程就马上退出了，并且不会影响到其他线程的正常运行，不管是在子线程或者主线程中都可以使用。 

  1. #include <pthread.h>  
  2. void pthread_exit(void *retval); 
  •  参数：线程退出的时候携带的数据，当前子线程的主线程会得到该数据。如果不需要使用，指定为 NULL

下面是线程退出的示例代码，可以在任意线程的需要的位置调用该函数： 

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <pthread.h>  
  6. // 子线程的处理代码  
  7. void* working(void* arg)  
  8. {  
  9.     sleep(1);  
  10.     printf("我是子线程, 线程ID: %ld\n", pthread_self()); 
  11.     for(int i=0; i<9; ++i)  
  12.     {  
  13.         if(i==6)  
  14.         {  
  15.             pthread_exit(NULL); // 直接退出子线程  
  16.         }   
  17.         printf("child == i: = %d\n", i);  
  18.     }  
  19.     return NULL;  
  20. } 
  21. int main()  
  22. {  
  23.     // 1. 创建一个子线程  
  24.     pthread_t tid;  
  25.     pthread_create(&tid, NULL, working, NULL);  
  26.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  27.     // 2. 子线程不会执行下边的代码, 主线程执行  
  28.     printf("我是主线程, 线程ID: %ld\n", pthread_self());  
  29.     for(int i=0; i<3; ++i)  
  30.     {  
  31.         printf("i = %d\n", i);  
  32.     }  
  33.     // 主线程调用退出函数退出, 地址空间不会被释放  
  34.     pthread_exit(NULL);   
  35.      return 0; 
  36. } 

四、线程回收

4.1 线程函数

线程和进程一样，子线程退出的时候其内核资源主要由主线程回收，线程库中提供的线程回收函叫做 pthread_join()，这个函数是一个阻塞函数，如果还有子线程在运行，调用该函数就会阻塞，子线程退出函数解除阻塞进行资源的回收，函数被调用一次，只能回收一个子线程，如果有多个子线程则需要循环进行回收。

另外通过线程回收函数还可以获取到子线程退出时传递出来的数据，函数原型如下： 

  1. #include <pthread.h>  
  2. // 这是一个阻塞函数, 子线程在运行这个函数就阻塞  
  3. // 子线程退出, 函数解除阻塞, 回收对应的子线程资源, 类似于回收进程使用的函数 wait()  
  4. int pthread_join(pthread_t thread, void **retval); 

参数:

  •  thread: 要被回收的子线程的线程 ID
  •  retval: 二级指针，指向一级指针的地址，是一个传出参数，这个地址中存储了 pthread_exit () 传递出的数据，如果不需要这个参数，可以指定为 NULL

返回值：线程回收成功返回 0，回收失败返回错误号。

4.2 回收子线程数据

在子线程退出的时候可以使用 pthread_exit() 的参数将数据传出，在回收这个子线程的时候可以通过 phread_join() 的第二个参数来接收子线程传递出的数据。接收数据有很多种处理方式，下面来列举几种：

4.2.1 使用子线程栈通过函数 pthread_exit(void *retval); 可以得知，子线程退出的时候，需要将数据记录到一块内存中，通过参数传出的是存储数据的内存的地址，而不是具体数据，由因为参数是 void* 类型，所有这个万能指针可以指向任意类型的内存地址。先来看第一种方式，将子线程退出数据保存在子线程自己的栈区： 

  1. // pthread_join.c  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <unistd.h>  
  5. #include <string.h>  
  6. #include <pthread.h>  
  7. // 定义结构  
  8. struct Persion  
  9. {  
  10.     int id;  
  11.     char name[36];  
  12.     int age;  
  13. };  
  14. // 子线程的处理代码  
  15. void* working(void* arg)  
  16. {  
  17.     printf("我是子线程, 线程ID: %ld\n", pthread_self());  
  18.     for(int i=0; i<9; ++i)  
  19.     {  
  20.         printf("child == i: = %d\n", i);  
  21.         if(i == 6)  
  22.         {  
  23.             struct Persion p;  
  24.             p.age  =12;  
  25.             strcpy(p.name, "tom");  
  26.             p.id = 100;  
  27.             // 该函数的参数将这个地址传递给了主线程的pthread_join()  
  28.             pthread_exit(&p);  
  29.         }  
  30.     }  
  31.     return NULL; // 代码执行不到这个位置就退出了  
  32. }  
  33. int main()  
  34. {  
  35.     // 1. 创建一个子线程  
  36.     pthread_t tid;  
  37.     pthread_create(&tid, NULL, working, NULL);  
  38.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  39.     // 2. 子线程不会执行下边的代码, 主线程执行  
  40.     printf("我是主线程, 线程ID: %ld\n", pthread_self());  
  41.     for(int i=0; i<3; ++i)  
  42.     {  
  43.         printf("i = %d\n", i);  
  44.     }  
  45.     // 阻塞等待子线程退出  
  46.     void* ptr = NULL;  
  47.     // ptr是一个传出参数, 在函数内部让这个指针指向一块有效内存  
  48.     // 这个内存地址就是pthread_exit() 参数指向的内存  
  49.     pthread_join(tid, &ptr);  
  50.     // 打印信息  
  51.     struct Persion* pp = (struct Persion*)ptr;  
  52.     printf("子线程返回数据: name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);  
  53.     printf("子线程资源被成功回收...\n");  
  54.     return 0;  
  55. } 

编译并执行测试程序: 

  1. # 编译代码  
  2. $ gcc pthread_join.c -lpthread  
  3. # 执行程序  
  4. $ ./a.out   
  5. 子线程创建成功, 线程ID: 140652794640128  
  6. 我是主线程, 线程ID: 140652803008256  
  7. i = 0  
  8. i = 1  
  9. i = 2  
  10. 我是子线程, 线程ID: 140652794640128  
  11. child == i: = 0  
  12. child == i: = 1  
  13. child == i: = 2  
  14. child == i: = 3  
  15. child == i: = 4  
  16. child == i: = 5  
  17. child == i: = 6  
  18. 子线程返回数据: name: , age: 0, id: 0  
  19. 子线程资源被成功回收... 

通过打印的日志可以发现，在主线程中没有没有得到子线程返回的数据信息，具体原因是这样的：

如果多个线程共用同一个虚拟地址空间，每个线程在栈区都有一块属于自己的内存，相当于栈区被这几个线程平分了，当线程退出，线程在栈区的内存也就被回收了，因此随着子线程的退出，写入到栈区的数据也就被释放了。

4.2.2 使用全局变量

位于同一虚拟地址空间中的线程，虽然不能共享栈区数据，但是可以共享全局数据区和堆区数据，因此在子线程退出的时候可以将传出数据存储到全局变量、静态变量或者堆内存中。在下面的例子中将数据存储到了全局变量中： 

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <pthread.h>  
  6. // 定义结构  
  7. struct Persion  
  8. {  
  9.     int id;  
  10.     char name[36];  
  11.     int age;  
  12. };  
  13. struct Persion p; // 定义全局变量  
  14. // 子线程的处理代码  
  15. void* working(void* arg)  
  16. {  
  17.     printf("我是子线程, 线程ID: %ld\n", pthread_self());  
  18.     for(int i=0; i<9; ++i)  
  19.     {  
  20.         printf("child == i: = %d\n", i);  
  21.         if(i == 6)  
  22.         {  
  23.             // 使用全局变量  
  24.             p.age  =12;  
  25.             strcpy(p.name, "tom");  
  26.             p.id = 100;  
  27.             // 该函数的参数将这个地址传递给了主线程的pthread_join()  
  28.             pthread_exit(&p);  
  29.         }  
  30.     }  
  31.     return NULL;  
  32. }  
  33. int main()  
  34. {  
  35.     // 1. 创建一个子线程  
  36.     pthread_t tid;  
  37.     pthread_create(&tid, NULL, working, NULL);  
  38.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  39.     // 2. 子线程不会执行下边的代码, 主线程执行 
  40.      printf("我是主线程, 线程ID: %ld\n", pthread_self());  
  41.     for(int i=0; i<3; ++i)  
  42.     {  
  43.         printf("i = %d\n", i);  
  44.     }  
  45.     // 阻塞等待子线程退出  
  46.     void* ptr = NULL;  
  47.     // ptr是一个传出参数, 在函数内部让这个指针指向一块有效内存  
  48.     // 这个内存地址就是pthread_exit() 参数指向的内存  
  49.     pthread_join(tid, &ptr);  
  50.     // 打印信息  
  51.     struct Persion* pp = (struct Persion*)ptr;  
  52.     printf("name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);  
  53.     printf("子线程资源被成功回收...\n");  
  54.      return 0; 
  55. } 

4.2.3 使用主线程栈

虽然每个线程都有属于自己的栈区空间，但是位于同一个地址空间的多个线程是可以相互访问对方的栈空间上的数据的。由于很多情况下还需要在主线程中回收子线程资源，所以主线程一般都是最后退出，基于这个原因在下面的程序中将子线程返回的数据保存到了主线程的栈区内存中： 

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <pthread.h>  
  6. // 定义结构  
  7. struct Persion  
  8. {  
  9.     int id;  
  10.     char name[36];  
  11.     int age;  
  12. };  
  13. // 子线程的处理代码  
  14. void* working(void* arg)  
  15. {  
  16.     struct Persion* p = (struct Persion*)arg;  
  17.     printf("我是子线程, 线程ID: %ld\n", pthread_self());  
  18.     for(int i=0; i<9; ++i)  
  19.     {  
  20.         printf("child == i: = %d\n", i);  
  21.         if(i == 6)  
  22.         {  
  23.             // 使用主线程的栈内存  
  24.             p->age  =12;  
  25.             strcpy(p->name, "tom");  
  26.             p->id = 100;  
  27.             // 该函数的参数将这个地址传递给了主线程的pthread_join()  
  28.             pthread_exit(p);  
  29.         }  
  30.     }  
  31.     return NULL;  
  32. } 
  33. int main()  
  34. {  
  35.     // 1. 创建一个子线程  
  36.     pthread_t tid;  
  37.     struct Persion p;  
  38.     // 主线程的栈内存传递给子线程  
  39.     pthread_create(&tid, NULL, working, &p);  
  40.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  41.     // 2. 子线程不会执行下边的代码, 主线程执行  
  42.     printf("我是主线程, 线程ID: %ld\n", pthread_self());  
  43.     for(int i=0; i<3; ++i)  
  44.     {  
  45.         printf("i = %d\n", i);  
  46.     }  
  47.     // 阻塞等待子线程退出  
  48.     void* ptr = NULL;  
  49.     // ptr是一个传出参数, 在函数内部让这个指针指向一块有效内存  
  50.     // 这个内存地址就是pthread_exit() 参数指向的内存  
  51.     pthread_join(tid, &ptr);  
  52.     // 打印信息  
  53.     printf("name: %s, age: %d, id: %d\n", p.name, p.age, p.id);  
  54.     printf("子线程资源被成功回收...\n");   
  55.      return 0;  
  56. } 

在上面的程序中，调用 pthread_create() 创建子线程，并将主线程中栈空间变量 p 的地址传递到了子线程中，在子线程中将要传递出的数据写入到了这块内存中。也就是说在程序的 main() 函数中，通过指针变量 ptr 或者通过结构体变量 p 都可以读出子线程传出的数据。

五、线程分离

在某些情况下，程序中的主线程有属于自己的业务处理流程，如果让主线程负责子线程的资源回收，调用 pthread_join() 只要子线程不退出主线程就会一直被阻塞，主要线程的任务也就不能被执行了。

在线程库函数中为我们提供了线程分离函数 pthread_detach()，调用这个函数之后指定的子线程就可以和主线程分离，当子线程退出的时候，其占用的内核资源就被系统的其他进程接管并回收了。线程分离之后在主线程中使用 pthread_join() 就回收不到子线程资源了。 

  1. #include <pthread.h>  
  2. // 参数就子线程的线程ID, 主线程就可以和这个子线程分离了  
  3. int pthread_detach(pthread_t thread); 

下面的代码中，在主线程中创建子线程，并调用线程分离函数，实现了主线程和子线程的分离： 

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <pthread.h>  
  6. // 子线程的处理代码  
  7. void* working(void* arg)  
  8. {  
  9.     printf("我是子线程, 线程ID: %ld\n", pthread_self());  
  10.     for(int i=0; i<9; ++i)  
  11.     {  
  12.         printf("child == i: = %d\n", i);  
  13.     }  
  14.     return NULL;  
  15. } 
  16. int main()  
  17. {  
  18.     // 1. 创建一个子线程  
  19.     pthread_t tid;  
  20.     pthread_create(&tid, NULL, working, NULL);  
  21.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  22.     // 2. 子线程不会执行下边的代码, 主线程执行  
  23.     printf("我是主线程, 线程ID: %ld\n", pthread_self()); 
  24.     for(int i=0; i<3; ++i)  
  25.     {  
  26.         printf("i = %d\n", i);  
  27.     }  
  28.     // 设置子线程和主线程分离  
  29.     pthread_detach(tid);  
  30.     // 让主线程自己退出即可  
  31.     pthread_exit(NULL);   
  32.      return 0; 
  33. } 

六、其他线程函数

6.1 线程取消

线程取消的意思就是在某些特定情况下在一个线程中杀死另一个线程。使用这个函数杀死一个线程需要分两步：

  •  在线程 A 中调用线程取消函数 pthread_cancel，指定杀死线程 B，这时候线程 B 是死不了的
  •  在线程 B 中进程一次系统调用（从用户区切换到内核区），否则线程 B 可以一直运行。

这其实和七步断肠散、含笑半步癫的功效是一样的，吃了毒药不动或者不笑也没啥事儿 

  1. #include <pthread.h>  
  2. // 参数是子线程的线程ID  
  3. int pthread_cancel(pthread_t thread); 
  •  参数：要杀死的线程的线程 ID
  •  返回值：函数调用成功返回 0，调用失败返回非 0 错误号。

在下面的示例代码中，主线程调用线程取消函数，只要在子线程中进行了系统调用，当子线程执行到这个位置就挂掉了。 

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <pthread.h>  
  6. // 子线程的处理代码  
  7. void* working(void* arg)  
  8. {  
  9.     int j=0;  
  10.     for(int i=0; i<9; ++i)  
  11.     {  
  12.         j++;  
  13.     }  
  14.     // 这个函数会调用系统函数, 因此这是个间接的系统调用  
  15.     printf("我是子线程, 线程ID: %ld\n", pthread_self());  
  16.     for(int i=0; i<9; ++i)  
  17.     {  
  18.         printf(" child i: %d\n", i);  
  19.     }  
  20.     return NULL;  
  21. }  
  22. int main()  
  23. {  
  24.     // 1. 创建一个子线程  
  25.     pthread_t tid;  
  26.     pthread_create(&tid, NULL, working, NULL);  
  27.     printf("子线程创建成功, 线程ID: %ld\n", tid);  
  28.     // 2. 子线程不会执行下边的代码, 主线程执行  
  29.     printf("我是主线程, 线程ID: %ld\n", pthread_self());  
  30.     for(int i=0; i<3; ++i)  
  31.     { 
  32.         printf("i = %d\n", i);  
  33.     }  
  34.     // 杀死子线程, 如果子线程中做系统调用, 子线程就结束了  
  35.     pthread_cancel(tid);  
  36.     // 让主线程自己退出即可  
  37.     pthread_exit(NULL);   
  38.      return 0;  
  39. } 

关于系统调用有两种方式：

  1.   直接调用 Linux 系统函数
  2.   调用标准 C 库函数，为了实现某些功能，在 Linux 平台下标准 C 库函数会调用相关的系统函数

6.2 线程 ID 比较

在 Linux 中线程 ID 本质就是一个无符号长整形，因此可以直接使用比较操作符比较两个线程的 ID，但是线程库是可以跨平台使用的，在某些平台上 pthread_t 可能不是一个单纯的整形，这中情况下比较两个线程的 ID 必须要使用比较函数，函数原型如下： 

  1. #include <pthread.h>  
  2. int pthread_equal(pthread_t t1, pthread_t t2); 
  •  参数：t1 和 t2 是要比较的线程的线程 ID
  •  返回值：如果两个线程 ID 相等返回非 0 值，如果不相等返回 0 
责任编辑：庞桂玉 来源： C语言与C++编程
C语言线程代码
相关推荐
高效使用C语言
const关键字的是constant的意思，即不变的，在C语言中作为关键字来告诉编译器变量是不可修改的。

2022-01-28 14:54:21

staticC语言编译器
手写线程池 - C 语言版
在各个编程语言的语种中都有线程池的概念，并且很多语言中直接提供了线程池，作为程序猿直接使用就可以了，下面给大家介绍一下线程池的实现原理。

2021-12-28 15:10:01

线程池C语言编程语言
C语言入门 const使用的理解
希望通过本文对CONST的介绍，能给你带来帮助。本文适合初学者阅读，希望对你有帮助，一起来看。

2011-07-14 09:09:14

const
C语言中可变参数的使用
究竟如何写可变参数的C函数以及这些可变参数的函数编译器是如何实现，这个问题却一直困扰了我好久。本文就这个问题进行一些探讨,希望能对大家有些帮助.

2011-05-13 17:25:34

C
使用开源库 GObject 和 libsoup 提升 C 语言编程能力
开源库GObject和libsoup做了很多工作，因此你可以专注于使用C语言开发神奇的应用。

2022-09-24 19:38:40

开源C 语言
聊聊Linux C下线程池的使用
线程池也是多线程的处理方式。是将“生产者”线程提出任务添加到“任务队列”，然后一些线程自动完成“任务队列”上的任务。

2021-02-01 08:28:24

Linux线程池Linux系统
在Swift中使用C语言的指针
ObjectiveC和C语言经常需要使用到指针。Swift中的数据类型由于良好的设计，使其可以和基于指针的C语言API无缝混用。同时Swift也可以自动处理大多数将指针作为参数的情况。

2014-08-01 15:16:05

SwiftC语言
源于C语言的C++语言解析
C++语言直至近日仍然在各种地方进行使用，其原因就是因为C++既保持了C语言级别的效率，又加入了面向对象的特性。

2010-01-15 17:38:37

C++语言
用 C 语言理解 Linux 软件库
软件库是一种是一直以来长期存在的、简单合理的复用代码的方式。这篇文章解释了如何从头开始构建库并使得其可用。尽管这两个示例库都以Linux为例，但创建、发布和使用这些库的步骤也可以应用于其它类Unix系统。

2021-05-24 06:40:59

C语言Linux软件库
线程池原理详解及如何用C语言实现线程池
线程池是一种多线程处理形式，大多用于高并发服务器上，它能合理有效的利用高并发服务器上的线程资源;线程与进程用于处理各项分支子功能，我们通常的操作是：接收消息消息分类线程创建传递消息到子线程线程分离在子线程中执行任务任务结束退出。

2020-03-05 15:34:16

线程池C语言局域网
Golang 语言的标准库 log 包怎么使用？
Golang语言的标准库中提供了一个简单的log日志包，它不仅提供了很多函数，还定义了一个包含很多方法的类型Logger。但是它也有缺点，比如不支持区分日志级别，不支持日志文件切割等。

2021-01-29 08:56:13

Golang标准库函数
使用C++语言编程学习切磋
决定学习C++语言时，而且我也尽量坚持每天一篇日志，尽量把自己所学的一点一滴留下点痕迹，加油吧，下面就开始吧。

2010-01-11 09:40:02

C++语言
C#语言操纵数据库事务
本文介绍C数据库事务是指作为单个逻辑工作单元执行的一系列操作。C数据库事务正是用来保证这种情况下交易的平稳性和可预测性的技术。

2009-08-06 18:10:06

C#数据库事务
Go 语言怎么使用 Zap 日志库？
本文我们通过在Gin构建的应用中，使用Zap记录请求日志，介绍了Zap的使用方式，最后还通过lumberjack日志切割库进行切割日志。

2023-02-13 00:24:37

Go语言日志库
Go 语言 Errgroup 库的使用方式和实现原理
本文我们介绍Go方法提供的errgroup库，该库最近新增了控制并发数量的功能。我们先介绍了三种使用方式，然后通过阅读源码，分析其实现原理。

2022-10-24 00:48:58

Go语言errgroup
C#线程的启动
本篇主要讲述C线程的启动问题，在启动时可能会遇到无需参数、需要多个参数的情况，在这里讲述了如何解决这些问题的思路。

2009-08-25 15:09:30

C#线程的启动
详述C++库的使用与维护工作
学习C++库两个主要原因：一，了解底层知识有助于写出高效的代码。二，C++这样的接近硬件的语言为了降低语言抽象的效率惩罚。

2010-01-12 11:03:04

C++库
C语言X-MACRO宏使用技巧
今天分享一个C语言宏定义小技巧，从语法上来看比较简单技巧，不过一旦真正领悟到其精妙之处不仅可以简化代码、还能提高代码的可扩展性。

2022-09-20 11:07:00

C语言X-MACRO技巧
C语言新手：什么是C语言
C语言是程序语言的基础，学会了C语言，在学其他的语言就简单多了。本文详细介绍了C语言。希望对初学者，有帮助，一起来看。

2011-07-05 16:57:53

C语言
为什么要学习和使用 C 语言？
对于理工科学生来说，这个答案可能很简单，因为这是一门必修课。而对于程序员来说选择一门编程语言，在某种程度上，对职业生涯的发展会产生重大的影响，所以必须慎之又慎。那么，为什么要选择一门诞生了将近半个世纪的语言？本文不是老生常谈的废话，如：&quot;C语言是编程的基础&quot;、&quot;学好C语言，走遍天下都不怕&quot;等等，本文力争详尽而又有理的回答这个问题，旨在...

2015-05-25 15:31:56

C语言学习和使用 C 语言
点赞
收藏

51CTO技术栈公众号

业务
速览
在线客服