c语言系统编程十二：Linux多任务编程之线程

已于 2022-09-06 10:48:30 修改
阅读量745 收藏 5
点赞数 1
分类专栏： c语言 C语言系统编程 文章标签： linux c语言 unix
于 2022-09-06 01:49:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33808440/article/details/125659192
版权

Linux多任务编程之线程

一 线程概述

1.1 概述

  1. 线程是轻量级的进程（LWP）；
  2. 在Linux环境下线程的本质仍然是进程；
  3. 为了让进程完成一定的工作，进程必须至少包含一个线程；
  4. 进程是系统分配资源的基本单位；
  5. 线程是cpu执行调度的基本单位；
  6. 线程依赖于进程，线程共享进程的资源，线程独立的资源有（计数器，一组寄存器，栈）；
  7. 进程结束，当前进程的所有线程都将立刻结束。

在这里插入图片描述

1.2 线程函数列表安装

在这里插入图片描述

1.3 线程的特点

类Unix系统中，早期没有线程的概念，80年代才引入，借助进程机制实现出了线程的概念，因此在这类系统中，进程和线程关系密切：

  1. 线程是轻量级进程，也有PCB，创建线程使用的底层函数和进程一样，都是clone；
  2. 从内核里看进程和线程是一样的，都有各自不同的PCB；
  3. 进程可以蜕变成线程；
  4. 在Linux下，线程是最小的执行单位；进程是最小的分配资源单位；

1.4 线程共享的资源

  1. 文件描述符表
  2. 每种信号的处理方式
  3. 当前工作目录
  4. 用户ID和组ID 内存地址空间(.text/.data/.bss/heap/共享库)

1.5 线程不共享的资源

  1. 线程id
  2. 处理器现场和栈指针（内核栈）
  3. 独立的栈空间（用户空间栈）
  4. errno变量
  5. 信号屏蔽字
  6. 调度优先级

1.6 在linux中查看指定进程的LWP号（线程id）

ps -Lf pid

在这里插入图片描述

二 查看进程号 pthread_self

2.1 需要的头文件和函数原型

#include <pthread.h>
pthread_t pthread_self(void);

2.2 函数功能

获取线程号

2.3 参数

无

2.4 返回值

调用函数的线程的线程id

2.5 实例

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int main(int arg,char *args[])
{
        printf("当前线程的线程id是%ld\n", pthread_self());
        getchar();
        return 0;
}

在这里插入图片描述

三 线程的创建 pthread_create

3.1 需要的头文件和函数原型

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

3.2 函数功能

创建一个线程

3.3 参数

thread: 线程标识符地址
attr：线程属性结构体地址，通常设置为 NULL
start_routine：线程函数的入口地址
art：传给线程函数的参数

3.4 返回值

成功：0
失败：非0

3.5 实例

3.5.1 实例一

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int main(int arg,char *args[])
{
        void * func(void *arg)
        {
                while (1)
                {
                        printf("在子线程%ld中\n", pthread_self());
                        sleep (1);
                }
                return NULL;

        }
        pthread_t thread1;
        int res = pthread_create(&thread1, NULL, func, NULL);
        printf("res=%d\n",res);
        printf("当前主线程的线程id是%ld\n", pthread_self());
        printf("创建的子线程id是%ld\n", thread1);
        getchar();
        return 0;

在这里插入图片描述

3.5.2 实例二 给函数传参数

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int main(int arg,char *args[])
{
        void * func(void *arg)
        {
                while (1)
                {
                        printf("在子线程%ld中\n", pthread_self());
                        printf("传来的参数是%s\n", (char *)arg);
                        sleep (1);
                }
                return NULL;

        }
        pthread_t thread1;
        int res = pthread_create(&thread1, NULL, func, "test123");
        printf("res=%d\n",res);
        printf("当前主线程的线程id是%ld\n", pthread_self());
        printf("创建的子线程id是%ld\n", thread1);
        getchar();
        return 0;
}

在这里插入图片描述

3.5.3 实例三 在线程函数中接收传来的参数时，如果用指针变量接收参数，由于参数就一份，那么不同线程都使用同一个线程函数时相互有影响；如果用普通变量来接收参数，由于是复制了一份原始参数来自己使用，所以多个线程使用同一线程函数时相互间不会影响

  1. 用指针变量接收参数，多个线程间相互影响
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
void *func1(void *args)
{
        int *p = (int *)args;
        while(1)
        {
                printf("fun1中子线程%ld中参数为%d\n",pthread_self(), *p);
                *p = *p+1;
                sleep(1);
        }
        return NULL;
}
int main(int arg,char *args[])
{
        pthread_t  lwp1;
        pthread_t  lwp2;
        int param1 = 1;
        pthread_create(&lwp1, NULL,func1,&param1);
        pthread_create(&lwp2, NULL,func1,&param1);
        pthread_join(lwp1,NULL);
        pthread_join(lwp2,NULL);
        return 0;
}

在这里插入图片描述

  1. 用普通变量来接收参数，多个线程间相互不影响
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
void *func1(void *args)
{
	int a = *(int *)args;
	while(1)
	{
		printf("fun1中子线程%ld中参数为%d\n",pthread_self(), a);
		a++;
		sleep(1);
	}
	return NULL;
}
int main(int arg,char *args[])
{
	pthread_t  lwp1;
	pthread_t  lwp2;
	int param1 = 1;
	pthread_create(&lwp1, NULL,func1,&param1);
	pthread_create(&lwp2, NULL,func1,&param1);
	pthread_join(lwp1,NULL);
	pthread_join(lwp2,NULL);
	return 0;
}

在这里插入图片描述

3.5.4 实例四 当需要多个参数传给线程函数时用结构体

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
typedef struct person
{

	char name[32];
	int age;
} PERSON;
void* func(void *args)
{
	PERSON man = *(PERSON *)args;
	while(1)
	{
		printf("我的名字叫%s\n",man.name);
		printf("我的年龄是%d\n",man.age);
		sleep(1);
	}
	return NULL;
}
int main(int arg,char *args[])
{
	pthread_t lwp1;
	PERSON person = {"tony",39};
	pthread_create(&lwp1, NULL, func, &person);
	pthread_join(lwp1,NULL);	
	return 0;
}

在这里插入图片描述

四 回收线程资源 pthread_join 和 pthread_detach

4.1 进程自己负责回收线程资源 pthread_join

会阻塞直到回收了要回收的线程

4.1.1 需要的头文件和函数原型

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

4.1.2 函数功能

等待线程结束（此函数会阻塞），并回收线程资源，类似进程的wait()函数。如果线程已经结束，那么该函数会立刻返回

4.1.3 参数

thread：被等待的线程号
retval：用来存储线程退出状态的指针的地址

4.1.4 返回值

成功：0
失败：非0

4.2 线程分离，让系统负责回收线程资源 pthread_detach

不会阻塞，回收线程资源的任务交给了系统；
一般情况下，线程终止后，其终止状态一直保留到其他线程调用pthread_join获取他的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收他占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。

4.2.1 需要的头文件和函数原型

#include <pthread.h>
int pthread_detach(pthread_t thread);

4.2.2 功能

使调用线程与当前进程分离，分离后不代表线程不依赖于当前进程，线程分离的目的是将线程资源的回收工作交由系统自动完成，也就是说当被分离的线程结束后，系统会自动回收他的资源。所以，此函数不会阻塞。

4.2.3 参数

thread：线程号

4.2.4 返回值

成功：0
失败：非0

4.2.5 实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *func1(void *args)
{
	int a  = *(int *)args;
	while(1)
	{
		printf("func1中子线程%ld中参数为%d\n",pthread_self(), a);
		sleep(1);
	}
	return NULL;
}
void *func2(void *args)
{
	char name[32] = "";
	memcpy(name, (char *)args ,strlen((char *)args));
	while(1)
	{
		printf("func2中子线程%ld中参数为%s\n",pthread_self(), name);
		sleep(1);
	}
	return NULL;

}
int main(int arg,char *args[])
{
	pthread_t  lwp1;
	pthread_t  lwp2;
	int param1 = 1;
	char param2[32] = "tony";
	int t1, t2, t3, t4;
	t1 = pthread_create(&lwp1, NULL,func1,&param1);
	printf("t1=%d\n", t1);
	t2 = pthread_create(&lwp2, NULL,func2,param2);
	printf("t2=%d\n", t2);
	t3 = pthread_detach(lwp1);
	printf("t3=%d\n", t3);
	t4 = pthread_detach(lwp2);
	printf("t4=%d\n", t4);
	getchar();
	return 0;
}

在这里插入图片描述

五 线程的退出和取消

在进程中我们可以调用exit或_exit函数来结束进程，在一个线程中我们可以通过以下三种方式在不终止整个进程的情况下停止线程的控制流。线程从执行函数中返回；线程调用pthread_exit退出线程；线程可以被同一进程中的其他线程取消。

5.1 线程的退出

5.1.1 需要的头文件和函数原型

#include <pthread.h>
void pthread_exit(void *retval);

5.1.2 功能

退出调用线程。一个进程中的多个线程是共享该进程的数据段，因此，通常线程退出后所占用的资源并不会释放

5.1.3 实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *func(void *args)
{
        int a  = *(int *)args;
        while(1)
        {
                printf("func中子线程%ld中参数为%d\n",pthread_self(), a);
                a++;
                if(a==5)
                        pthread_exit(NULL);
                sleep(1);
        }
        return NULL;
}
int main(int arg,char *args[])
{
        pthread_t  lwp1;
        pthread_t  lwp2;
        int param1 = 1;
        pthread_create(&lwp1, NULL,func,&param1);
        pthread_create(&lwp2, NULL,func,&param1);
        pthread_detach(lwp1);
        pthread_join(lwp2,NULL);
        return 0;
}

在这里插入图片描述

5.2 线程的取消

可以取消自己；也可以取消当前进程中的其他线程；

5.2.1 需要的头文件和函数原型

#include <pthread.h>
int pthread_cancel(pthread_t thread);

5.2.2 功能

杀死（取消）线程

5.2.3 参数

thread：要取消的线程id

5.2.4 返回值

成功：0
失败：出错编号

5.2.5 注意事项

线程的取消并不是实时的，而是有一定的延时，需要等待线程到达某个取消点（检查点）。类似于玩游戏存档，必须到达指定的场所才能存储进度。杀死线程也不是立刻就能完成，必须要到达取消点。取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，close，read等。

5.2.6 实例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
void * pthread_fun01(void * arg)
{
        int i = 0;
        while(1)
        {
                printf("%s---------i=%d\n", (char *)arg, i++);
                sleep(1); //取消点
        }
        return NULL;
}
int main(int arg,char *args[])
{
        // 创建线程
        pthread_t tid1;
        pthread_create(&tid1, NULL, pthread_fun01, "任务A");
        //线程分离
        pthread_detach(tid1);
        printf("5秒后结束任务A\n");
        sleep(5);
        pthread_cancel(tid1);
        getchar();
        return 0;
}

在这里插入图片描述

六 线程的属性

Linux下线程的属性是可以根据实际项目需要，进行设置，之前我们讨论的线程都是采用默认线程属性来创建的，默认属性已经可以解决绝大多数开发遇到的问题了。如果我们对程序的性能提出更高要求那么需要设置线程属性，比如可以通过设置线程栈的大小来降低内存的使用，增加最大线程个数

6.1 线程属性的结构体成员

typedef struct
{
        int etachstate;  //线程的分离状态
        int schedpolicy;  //线程调度策略
        struct sched_param schedparam;  //线程的调度参数
        int  inheritsched;  //线程的继承性
        int  scope;   //线程的作用域
        size_t guardsize;  //线程栈末尾的警戒缓冲区大小
        int  stackaddr_set;  //线程的栈设置
        void*  stackaddr;  //线程栈的位置
        size_t  stacksize;  //线程栈的大小
} pthread_attr_t;

6.2 线程属性初始化

线程属性初始化函数为pthread_attr_init, 这个函数必须在pthread_create函数之前调用。之后需要用pthread_attr_destroy函数来释放资源。线程属性主要包括如下属性：作用域、栈尺寸、栈地址、优先级、分离状态、调度策略和参数。默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。
注意：应先初始化线程属性，再pthread_create创建线程
初始化线程属性函数：int pthread_attr_init(pthread_attr_t *attr);
返回值：成功：0；失败：错误号

6.3 销毁线程属性所占用的资源

int pthread_attr_destroy(pthread_attr_t *attr);
返回值：成功：0；失败：错误号

6.4 设置线程的分离状态

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
参数：
	attr：已经初始化的线程属性
	detachstate：分离状态 PTHREAD_CREATE_DETACHED（分离线程）
										 PTHREAD_CREATE_JOINABLE（非分离线程）
注意：如果设置一个线程为分离线程，而这个线程运行又非常快，他很可能在pthread_create函数返回之前就终止了，他终止以后就可能将线程号和系统资源移交给其他线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采用一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait函数，让这个线程等待一会，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。

6.5 获取线程的分离状态

int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstat);
参数：
	attr：已经初始化的线程属性
	detachstate：分离状态 PTHREAD_CREATE_DETACHED（分离线程）
										 PTHREAD_CREATE_JOINABLE（非分离线程）

6.6 设置线程的栈地址

当进程栈地址空间不够时，指定新建线程使用由malloc分配的堆空间作为栈空间。
int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);
返回值：成功：0；失败：错误号

6.7 获取线程的栈地址

int pthread_attr_getstack(pthread_attr_t *attr, void **stackaddr, size_t *stacksize);
参数：
	attr：指向一个线程属性的指针
	stackaddr：返回获取的栈地址
	stacksize：返回获取的栈大小
返回值：成功：0；失败：错误号

6.8 设置线程的栈大小

当系统中有很多线程时，可能需要减小每个线程栈的默认大小，防止进程的地址空间不够用，当线程调用的函数会分配很大的局部变量或者函数调用层次很深时，可能需要增大线程栈的默认大小。
int pthead_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
参数：
	attr：指向一个线程属性的指针
	stacksize：返回线程的堆栈大小
返回值：成功0；失败：错误号

6.9 获取线程的栈大小

int pthead_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);
参数：
	attr：指向一个线程属性的指针
	stacksize：返回线程的堆栈大小
返回值：成功0；失败：错误号

6.10 线程属性总和案例

#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define SIZE 0x100000

void *th_fun(void *arg)
{
	while(1)
		sleep(1);
}

int main(int arg,char *args[])
{
	pthread_t tid;
	int err, detachstate, i=1;
	pthread_attr_t attr;
	size_t stacksize;
	void *stackaddr;

	pthread_attr_init(&attr);
	pthread_attr_getstack(&attr, &stackaddr, &stacksize);
	pthread_attr_getdetachstate(&attr, &detachstate);

	if(detachstate == PTHREAD_CREATE_DETACHED)
		printf("thread detached\n");
	else if(detachstate == PTHREAD_CREATE_JOINABLE)
		printf("thread join\n");
	else
		printf("thread unknown\n");

	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

	while(1)
	{
		stackaddr = malloc(SIZE);
		if(stackaddr == NULL)
		{
			perror("malloc");
			exit(1);
		}
		stacksize = SIZE;
		pthread_attr_setstack(&attr, stackaddr, stacksize);
		err = pthread_create(&tid, &attr, th_fun, NULL);
		if(err != 0)
		{
			printf("err=%d\n", err);
			printf("%s\n", strerror(err));
			exit(1);
		}
		printf("%d\n", i++);
	}
	pthread_attr_destroy(&attr);
	return 0;
}

在这里插入图片描述

在这里插入图片描述

七 创建多线程

#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
typedef struct
{
	int time;
	char task_name[32];
} MSG;

void *deal_fun(void *arg)
{
	MSG msg = *(MSG *)arg;
	int i = 0;
	for(i=msg.time; i>0; i--)
	{
		printf("%s剩余时间%d\n", msg.task_name, i);
		sleep(1);
	}
	return NULL;
}

int main(int arg,char *args[])
{
	while(1)
	{
		MSG msg;
		printf("输入新增的任务名:");
		fgets(msg.task_name, sizeof(msg.task_name), stdin);
		msg.task_name[strlen(msg.task_name)-1]=0;
		printf("输入运行时间：");
		scanf("%d", &msg.time);
		getchar();//获取换行符
		pthread_t tid;
		pthread_create(&tid, NULL, deal_fun, (void *)&msg);
		pthread_detach(tid);//线程分离
	}
	return 0;
}

在这里插入图片描述

qq_33808440
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下的C语言多线程编程
03-24
使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空 间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址 空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
C语言系统编程技术点
pony12的专栏
06-08 1285
包含一些编程概念和知识点，仅仅是列举而已，供大家了解和自我检验。
【LinuxC】C语言线程（pthread）
最新发布
满堂花醉三千客，一剑霜寒十四州
03-14 1125
LinuxC 线程基操。
C语言嵌入式系统编程-----软件架构篇
张亮校的专栏
12-06 1575
模块划分 模块划分的"划"是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求。C语言作为一种结构化的程序设计语言，在模块的划分上主要依据功能（依功能进行划分在面向对象设计中成为一个错误，牛顿定律遇到了>相对论）， C语言模块化程序设计需理解如下概念： （1） 模块即是一个.c文件和一个.h文件的结合，头文件(.h)中是对于该模块接口的声明； （2
linux下C语言多线程
koches的专栏
07-25 1万+
下面先来一个实例来感受下linux下C语言多线程编程的乐趣！我们通过创建两个线程来实现对一个数的递加。先不去理会代码的含义，我们先运行linux，在其中编写我们的第一个C语言多线程程序。 #include #include #include #include #define MAX 10 pthread_t thread[2]; pthread_mutex_t mut; i
Linux下c语言多线程编程
u011029104的专栏
03-28 206
引言 　　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多 　　为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 　　使用...
Linux多线程 C语言编程关于多线程
03-27
csdn Linux 下的多进程编程初步 摘要：多线程程序设计的概念早在六十年代就被提出，但直到八十年代中期，Unix 系 ...和早期的Windows 不同，Unix/Linux 系统是真正实现多任务操作的系统，可以说，不使. . . ./ .
基于Linux的网络编程——网络聊天程序
09-02
网络聊天程序是目前应用极为广泛的一种网络软件，对于方便人们的交流沟通非常有效，同时，... 程序基于Linux系统开发，纯C语言Socket实现多个客户端之间通信，由服务器端进行数据处理，基本实现聊天功能的基础运用。
浅析如何在c语言中调用Linux脚本
01-20
与DOS和早期的Windows不同，Unix/Linux系统是真正实现多任务操作的系统，可以说，不使用多进程编程，就不能算是真正的Linux环境下编程。 多线程程序设计的概念早在六十年代就被提出，但直到八十年代中期，Unix系统中...
linux网络编程课程设计
01-08
（1）在Linux系统下，使用TCP协议套接字编程； （2）服务器应具有处理多个客户端连接并计算的能力； （3）过程描述 客户端：连接服务器后，从键盘输入一连串的整数及字符串，并将这些整数及字符串发送到服务器，并...
C语言编程系统
12-16
C语言课后题编程，关于数组指针和指向指针的指针应用的小程序，大家可以看一下
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 使用命令cc consumer.c -o consumer编译
Linux C 线程编程
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-24 3033
线程创建、线程退出、线程等待、线程同步、线程池、进程与线程
linux下c语言多线程程序,linux下线程概念及用C语言实现示例
weixin_35537968的博客
05-03 407
1、线程的状态线程有5种状态：初始化、可运行、运行中、阻塞、销毁。①初始化：创建一个线程。②可运行：执行完创建工作，线程变进入“可运行”的状态，即等待CPU时间碎片(执行权)。③运行中：得到CPU执行权后，程序变为“运行中”的状态，此时可以转变为“可运行”的状态(一个时间碎片执行完后)，或者“阻塞”的状态(等待网络或者磁盘处理)。④阻塞：当发生I/O时，就进入了“阻塞”状态。⑤销毁：线程生命周期结...
linux系统 c语言 多线程
lcx123_的博客
04-29 123
linux系统 c语言 多线程 #include<pthread.h> #include<stdio.h> #include<unistd.h> //pthread fun void *my_th1(void *id){ printf("线程1创建"); while(1){ printf("线程1...\n"); //printf("100ms\n"); usleep(100000); } } void *my_th2(void *id){ prin
linux下的C语言开发（多线程编程）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
02-06 3万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     多线程和多进程还是有很多区别的。其中之一就是，多进程是linux内核本身所支持的，而多线程则需要相应的动态库进行支持。对于进程而言，数据之间都是相互隔离的，而多线程则不同，不同的线程除了堆栈空间之外所有的数据都是共享的。说了这么多，我们还是自己编写一个多线程程序看看结果究竟是怎么
Linux系统下C语言线程
u013445609的博客
10-02 243
先上代码 /* * gcc multiple_thread.c -lpthread -o multiple_thread */ #include <stdio.h> #include <pthread.h> #include <unistd.h> #include <signal.h> #include <sys/param.h> ...
能给我推荐一些基于C语言的多线程编程资源吗？
03-20
当然可以，以下是一些基于C语言的多线程编程资源： 1. POSIX Threads (Pthreads)：这是一种标准的多线程API，可用于Unix和Linux系统。它提供了一组函数，用于创建和管理线程，以及同步和通信。 2. OpenMP：这是一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值