文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

C语言线程库的使用

2024-12-02 17:39

关注

一、线程概述

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

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

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

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

    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 

参数:

返回值：线程创建成功返回 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); 

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

  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); 

参数:

返回值：线程回收成功返回 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 线程取消

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

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

  1. #include <pthread.h>  
  2. // 参数是子线程的线程ID  
  3. int pthread_cancel(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.     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); 
来源：C语言与C++编程内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

C语言线程库的使用

后端开发C语言线程2024-12-02

c语言线程编程是什么(c中线程的使用)

后端开发2023-09-22

c语言多线程库怎么调用

后端开发2023-09-21

c语言怎么使用多线程

c语言怎么使用多线程
后端开发2024-05-21

c语言多线程怎么用

c语言多线程怎么用
后端开发2024-05-15

c语言怎么调用多线程

后端开发2023-09-15

使用C语言怎么对线程对象和线程进行存储

后端开发2023-06-08

C 语言编程 — pthread 用户线程操作

后端开发2023-09-10

C语言多线程pthread库的相关函数有哪些

后端开发2023-08-18

C语言库函数qsort的使用详解

后端开发2024-04-02

C语言常用的库函数怎么使用

后端开发2023-06-30

手写线程池 - C 语言版

后端开发线程池C语言2024-12-02

关于C语言多线程pthread库的相关函数说明

后端开发2023-08-17

C语言库函数qsort如何使用

后端开发2023-07-02

go语言多线程怎么使用

后端开发2023-08-31

C语言string库strcpy、strcmp、strcat函数的使用

后端开发2023-02-24

Windows下C语言多线程函数

后端开发2023-09-14

c语言多线程怎么共享

c语言多线程怎么共享
后端开发2024-05-21

详解Dev C++使用教程(使用Dev C++编写C语言程序)

后端开发2024-04-02

C语言使用ffmpeg实现单线程异步的视频播放器

后端开发2022-12-16
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯