【操作系统】c语言--进程调度算法(FCFS和SPN)

已于 2023-07-10 06:13:57 修改
阅读量1.9k 收藏 47
点赞数 7
文章标签： c语言 算法 开发语言 笔记 学习
于 2023-07-05 21:08:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TiSg0/article/details/131563798
版权

创作不易，本篇文章如果帮助到了你，还请点赞 关注支持一下♡>𖥦<)!!
主页专栏有更多知识，如有疑问欢迎大家指正讨论，共同进步！
🔥c++系列专栏：C/C++零基础到精通 🔥

给大家跳段街舞感谢支持！ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ

在这里插入图片描述

c语言内容💖：

专栏：c语言之路重点知识整合

【c语言】全部知识点总结

目录

一、先到先服务进程调度算法

先来先服务进程调度算法（FCFS）是按照进程到达的先后顺序进行调度的算法。

当一个进程到达时，它会被放到进程队列的末尾，并在前面等待其他进程执行完毕。

一旦轮到该进程执行，它会一直执行直到完成，或者被阻塞，或者需要等待I/O操作完成。

#include <stdlib.h>
#include <stdio.h>

typedef struct 
{   // 定义一个结构体，里面包含的有一个进程相关的信息
	char name[10];        //进程名称 (输入)
	float arrivetime;     //到达时间 (输入)
	float servicetime;    //服务时间 (输入)
	float starttime;      //开始时间
	float finishtime;     //结束时间
	float zztime;        //周转时间=finishtime-arrivetime
	float dqzztime;      //带权周转时间=zztime/servicetime
}pcb;


//输入进程信息
void input(pcb* p, int N)    //p为pdb数组名， N为pcb数组的元素个数
{
	int i;
	printf("\n");
	printf("请输入进程的名字  到达时间  服务时间:  (例如: 进程1 0 100)\n");
	for (i = 0; i <= N - 1; i++)
	{
		printf("请输入进程%d的信息：", i + 1);  // i=0时，输入第1个进程相关信息
		scanf("%s", &p[i].name);
		scanf("%f", &p[i].arrivetime);
		scanf("%f", &p[i].servicetime);
	}
}


//排序: 按照进程的arrivetime（从小到大）对pcb数组中的N个进程进行排序
void sort(pcb* p, int N)
{
	for (int i = 0; i < N - 1; i++)
	{
		for (int j = i + 1; j < N; j++)
		{
			if (p[i].arrivetime > p[j].arrivetime)
			{
				pcb temp;
				temp = p[i];
				p[i] = p[j];
				p[j] = temp;
			}
		}
	}
}


//运行
void run(pcb* p, int N)
{
	int k;
	for (k = 0; k <= N - 1; k++)
	{
		if (k == 0) //第1个进程
		{
			p[k].starttime = p[k].arrivetime; //第1个进程到达之后即可执行
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}
		else
		{
			p[k].starttime = (p[k - 1].finishtime >= p[k].arrivetime) ? p[k - 1].finishtime : p[k].arrivetime;
			p[k].finishtime = p[k].starttime + p[k].servicetime;

		}
	}

	for (k = 0; k <= N - 1; k++)
	{
		p[k].zztime = p[k].finishtime - p[k].arrivetime;
		p[k].dqzztime = p[k].zztime / p[k].servicetime;
	}
}


//显示
void Print(pcb* p, int N)
{
	int k;
	printf("调用先来先服务算法以后进程运行的顺序是: ");
	printf("%s", p[0].name); //首先运行第一个进程p[0]
	for (k = 1; k < N; k++)
	{
		printf("-->");
		printf("%s", p[k].name); //输出 -->p[k].name
	}

	printf("\n");
	printf("具体进程调度信息:\n");
	printf("进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
	for (k = 0; k <= N - 1; k++)
	{
		printf("%4s", p[k].name);
		printf("%10.3f", p[k].arrivetime);
		printf("%10.3f", p[k].servicetime);
		printf("%10.3f", p[k].starttime);
		printf("%10.3f", p[k].finishtime);
		printf("%10.3f", p[k].zztime);
		printf("%10.3f\n", p[k].dqzztime);
	}
}


//先来先服务算法FCFS
void FCFS(pcb* p, int N)
{
	sort(p, N);
	run(p, N);
	Print(p, N);
	int k;
	float Attime = 0; //平均周转时间
	float AQttime = 0; //平均带权周转时间
	for (k = 0; k <= N - 1; k++)
	{
		Attime += p[k].zztime;
		AQttime += p[k].dqzztime;
	}
	Attime = Attime / N;
	AQttime = AQttime / N;
	printf("调用先来先服务算法的平均周转时间为:");
	printf("%.3f\n", Attime);
	printf("调用先来先服务算法的平均带权周转时间为:");
	printf("%.3f\n", AQttime);
}

int main()
{
	pcb a[100]; //a为pcb数组   a[0]~a[N-1]对象第1个进程到第N个进程的信息
	int N;      //N为进程数目
	printf("\n");
	printf("\n");
	printf("<<----------先到先服务调度算法---------->>");
	printf("\n");
	printf("请输入进程数目:");
	scanf("%d", &N);
	input(a, N); //a是pcb数组名，N是实际使用数组元素个数
	FCFS(a, N); //fcfs模拟调度
	return 0;
}

在这里插入图片描述

二、短进程优先调度算法

短进程优先调度算法（SPN）是根据进程执行时间短的优先级进行调度的算法。
当一个进程到达时，系统会估算其执行时间，如果短于当前正在执行的进程，那么该进程就会优先执行。如果有多个进程具有相同的最短执行时间，那么默认使用FCFS算法。

#include <stdlib.h>
#include <stdio.h>

//定义一个结构体：PCB

typedef struct{
char name[10];
float arrivetime;
float servicetime;
float starttime;
float finishtime;
float zztime;
float dqzztime;
}pcb;

 //***输入进程信息，将N个进程的信息写入pcb型数组***
void input(pcb *p,int N)
{
	int i;
	printf("\n");
	printf("请输入进程的名字  到达时间  服务时间:  (例如: a 0 100)\n");

	for(i=0; i <= N-1; i++)
	{
		printf("请输入进程%d的信息：", i+1);
		scanf("%s", &p[i].name);
		scanf("%f", &p[i].arrivetime);
		scanf("%f", &p[i].servicetime);
	}
}



 //***优先级排序***
void sort(pcb *p, int N)
{
	/*
	1、对pcb型数组中的元素进行一个简单的排序
	找到优先级最高的进程
	并把其他进程也进行简单排序，方便后续工作
	*/

	//排序: N次循环,每次找到从i到N-1中优先级最高的进程，放到p[i]
	for(int i=0;i<=N-1;i++)
	{
		//循环比较剩余的变量    //排序后：从0~N-1  arrivetime增加 ， arrivetime相同时， servicetime短的优先
		for(int j=i+1;j<N;j++)
		{
			if(p[i].arrivetime>p[j].arrivetime || (p[i].arrivetime==p[j].arrivetime && p[i].servicetime>p[j].servicetime) )
			{
				//p[j]的优先级高于p[i],因此把p[j]放到p[i]
				pcb temp;
				temp = p[i];
				p[i] = p[j];
				p[j] = temp;
             }
		}
	}

	/*
	2、每个进程运行完成之后，找到当前时刻已经到达的最短进程
	P[0]优先级最高，p[0].finishtime=p[0].arrivetime+p[0].servicetime
	m!=0时：p[m].finishtime=p[m-1].finishtime+p[m].servicetime
	*/

	for(int m=0; m<N-1; m++)
	{
		if(m == 0)
			p[m].finishtime = p[m].arrivetime + p[m].servicetime;
		else
			p[m].finishtime = ((p[m-1].finishtime >= p[m].arrivetime)? p[m-1].finishtime: p[m].arrivetime) + p[m].servicetime;

		//(1)找到p[m].finishtime时刻哪些进程已经到达
		int i=0;  //i统计 p[m].finishtime时刻有几个进程已经到达
		//从下一个进程p[m+1]开始寻找
		for(int n = m+1; n <= N-1; n++)
		{
			if(p[n].arrivetime <= p[m].finishtime)
				i++;
			else
				break;

			    /*由于在第1步已经对进程按照到达时间进行了排序
			      故：当p[n].arrivetime > p[m].finishtime时，
				      说明p[n]进程和其后面的其他进程都未到达。
				i的值为p[m].finishtime时刻已经到达的进程数目。
			   */
		}

		//(2)找到p[m].finishtime时刻已经到达的最短进程
		float min = p[m+1].servicetime;   //next进程服务时间为p[m+1].servicetime （初值）
		int next = m+1;                   //next进程为m+1 （初值）
		//p[m+1]至p[m+i]这i个已到达进程中找到最短进程
		for(int k = m+1; k < m+i; k++)       //k为m+1 ~ m+i-1
		{
			//min的初值是p[m+1].servicetime, k+1为m+2 ~m+i
			if(p[k+1].servicetime < min)
			{
				min = p[k+1].servicetime;
				next = k+1;
			}
		}

		//(3)把最短进程放在p[m+1]进程处
		pcb temp;
		temp=p[m+1];
		p[m+1]=p[next];
		p[next]=temp;
	}
}






 //***运行***
void run(pcb *p, int N)
{
	int k;
	//计算各进程的开始时间和结束时间
	for(k=0; k <= N-1; k++)
     {
		if(k==0) //第1个进程
		{
			p[k].starttime = p[k].arrivetime; //第1个进程到达之后即可执行
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}
		else
		{
			p[k].starttime = (p[k-1].finishtime >= p[k].arrivetime)? p[k-1].finishtime: p[k].arrivetime;
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}
	}

	//计算各进程的周转时间和带权周转时间
	for(k=0; k<=N-1; k++)
	{
		p[k].zztime = p[k].finishtime - p[k].arrivetime;
		p[k].dqzztime = p[k].zztime / p[k].servicetime;
     }
}




//***显示***
void Print(pcb *p, int N)
{
	int k;
	printf("调用最短进程优先算法以后进程运行的顺序是: ");
	printf("%s",p[0].name);
	for(k=1;k<N;k++)
	{
		printf("-->");
		printf("%s", p[k].name);
	}

	printf("\n");
	printf("具体进程调度信息:\n");
	printf("进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
	for(k=0; k<=N-1; k++)
	{
		printf("%4s", p[k].name);
		//%m.nf：输出共占m列，其中有n位小数，如数值宽度小于m左端补空格
		printf("%10.3f", p[k].arrivetime);
		printf("%10.3f", p[k].servicetime);
		printf("%10.3f", p[k].starttime);
		printf("%10.3f", p[k].finishtime);
		printf("%10.3f", p[k].zztime);
		printf("%10.3f\n", p[k].dqzztime);
	}
}






 //***短进程优先***
void sjff(pcb *p,int N)
{
	sort(p, N);
	run(p, N);
	Print(p, N);
	int k;
	float Attime = 0; // 平均周转时间
	float AQttime = 0; //平均带权周转时间
	for(k=0; k<=N-1; k++)
     {
		Attime += p[k].zztime;
		AQttime += p[k].dqzztime;
     }
	Attime = Attime/N;
	AQttime = AQttime/N;
	printf("调用短进程优先算法的平均周转时间为:");
	printf("%.3f\n", Attime);
	printf("调用短进程优先算法的平均带权周转时间为:");
	printf("%.3f\n", AQttime);
}





//***主函数***
int main()
{
	//定义一个pcb型数组a
	pcb a[100];
	int N;  //进程数目
	printf("\n");
	printf("\n");
	printf("<<----------******短进程优先调度算法******---------->>");
	printf("\n");
	printf("输入进程数目:");
	scanf("%d", &N);
	input(a, N);
	sjff(a, N);
	return 0;
}

在这里插入图片描述

在这里插入图片描述

大家的点赞、收藏、关注将是我更新的最大动力！ 欢迎留言或私信建议或问题。
大家的支持和反馈对我来说意义重大，我会继续不断努力提供有价值的内容！如果本文哪里有错误的地方还请大家多多指出(●'◡'●)
天喜Studio
关注
用c语言实现动态优先权调度,动态优先权的进程调度算法
weixin_35878683的博客
05-23 2173
(1)用C语言来实现对N个进程采用动态优先权优先算法的进程调度。(2)每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：?进程标识数ID；?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高；?进程已占用的CPU时间CPUTIME；?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0；?进程的阻塞时间STARTBLOCK，表示当进...
【C语言源代码】 操作系统-短进程优先-进程调度算法
02-10
C语言实现：短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。 2. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
操作系统进程调度算法 c语言实现
04-07
实现进程调度算法，具有后备序列的调度 题目：设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。 重复以上过程，直到所有进程都完成为止。
操作系统 ---- 调度算法【先来先服务(FCFS)、最短作业优先(SJF)、最高响应比优先(HRRN)】
xinxin的博客
09-13 3232
我们可以这样来看作业的优先级，对于先来先服务调度算法，作业的等待时间就是作业的优先级，等待时间越长，其优先级越高。对于短作业优先调度算法，作业的长短就是作业的优先级，作业所需运行的时间越短，其优先级越高。但上述两种优先级都不能反映作业的紧迫程度。优先级进程调度算法，是把处理机分配给就绪队列中优先级最高的进程。这时，又可进一步把该算法分成如下两种。(1) 非抢占式优先级调度算法。(2) 抢占式优先级调度算法。FCFS算法的优点是公平SJF算法的优点是能尽快处理完短作业，平均等待/周转时间等参数很优秀。
操作系统——短进程优先调度算法
weixin_52139418的博客
06-06 1263
printf("序号 到达时刻 服务时间 开始执行时间 完成时间 周转时间 带权周转时间\n");如果当前时间小于进程的到达时间，则将当前时间更新为进程的到达时间，以确保按照进程的到达顺序进行处理;// 如果当前时间小于进程的到达时间，则将当前时间更新为进程的到达时间。从已到达的进程里寻找最短服务时间的进程，执行最短服务时间的进程；// 更新当前时间和总周转时间。// 寻找最短的服务时间进程。// 执行最短服务时间的进程。// 按照到达时间对进程进行排序。// 初始化当前时间和总周转时间。
操作系统4种进程调度算法（c语言）
weixin_74337975的博客
11-14 4065
抢占性的 HPF 允许正在执行的进程被更高优先级的进程中断，以便立即执行更高优先级的任务。需要注意的是，SJF 算法的一个问题是它对于长服务时间的进程可能会导致其他进程长时间等待，可能会出现饥饿（Starvation）的情况。这是一种非抢占式的调度算法，即一旦进程开始执行，就一直执行到完成，除非有更短的作业进入就绪队列。在这种算法中，进程按照它们到达就绪队列的顺序依次执行，即先到达的进程先执行，后到达的进程排队等待。如果新进程的服务时间比当前正在执行的进程更短，那么系统会中断当前进程，转而执行新的进程。
操作系统——进程调度 C语言版
li1441853031的博客
07-01 3436
先来先服务FCFS算法：进程先进入的先服务。 短作业优先SJF算法：根据当前到来的进程，筛选当前所有进程中所需运行时间最短的进程。 时间片轮转算法：根据时间片的大小，切换进程，直到每个进程都运行完成。 计算出每个进程的开始时间，结束时间，周转时间T=开始时间-到达时间，带权周转时间W = T/运行时间，平均周转时间，平均带权周转时间。 #include <stdio.h> #include <stdlib.h> #include<string.h> typedef str
操作系统进程调度实现算法（c语言版）
热门推荐
qq_41552756的博客
06-21 2万+
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;windows.h&gt;   //包含sleep函数#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFESIBLE -1#define OVERFLOW -2struct PCB{ char...
先来先服务算法、运行时间最短者优先算法和最高响应比优先调度算法_Linux进程调度：完全公平调度器CFS
weixin_39649405的博客
10-22 630
对于分时操作系统来说，表面上看起来同时多个进程在运行，其实系统内部同一时间只有一个进程在运行，但进程是以比较快的速度在切换。这样就引入了进程切换和进程调度的概念了。进程调度应该是操作系统的核心功能了，它非常的复杂。尽管刚出Linux开发为的是桌面操作系统，但现在服务器，嵌入式设备，个人pc都会使用它，不同领域对进程调度的差异非常大，所以要考虑整体的平衡性。Linux进程在调度器中被分为三种：交互式...
【操作系统】【C语言】：C语言实现进程调度
qq_53690996的博客
01-04 7024
其中包含两个带头结点的链表表示的队列分别为就绪队列和阻塞队列，首先创建就绪队列ready和阻塞队列block，创建一个后期循环调度需要用到的中间进程队列end，首先循环遍历进程队列中各个进程结点，将进程状态为就绪的进程结点插入就绪队列中，将进程状态为阻塞的进程结点插入阻塞队列中。输入进程数为3，第一个进程的进程ID为1，优先数为3，需要运行的时间为4，时间2之后进入阻塞，阻塞时间为2，第二个进程进程ID为2，优先数为1，需要运行的时间为3，创建相应的就绪队列和阻塞队列的头节点解决了此问题。
C/C++实现操作系统进程调度算法，FCFS, RR, SPN, SRT, HRRN
crazybobo1207的博客
10-02 907
进程信息定义在方法InitProcedureInfo中，包括：procedureID（进程ID）, arriveTime（进程到达时间）, serviceTime（服务时间）, eclapsedTime（已服务时间）, remainTime（剩余服务时间）, accumulateTime（累计服务时间）。本程序的优点在于，一旦实现了其中一个调度算法，比如实现了最基本的FCFS之后，只要增加一个排序逻辑，即在重载
操作系统进程调度算法C语言代码
12-08
操作系统进程调度算法C语言代码 本算法包含四种调度:先到先服务，短作业优先，时间片轮转，优先级优先！
C语言进程调度
10-19
用C实现进程轮转调度和优先级调度，具体要求： 设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。 调度算法: 时间片循环法 1、 设计进程控制块PBC表结构，适用循环时间片轮转算法。 2、 PBC结构通常包括以下信息：进程名、进程优先数、轮转时间片、进程的CPU时间，进程状态等。根据调度算法不同，PCB结构可作适当的调整。 3、 建立进程队列。对不同的算法编制不同的入链程序。 程序要求达到的运行效果：在设置好进程数量、调度算法后，系统能按设定的参数运行，并在屏幕上交替显示就绪队列和完成队列的进程名等信息。
操作系统进程调度优先级算法C语言模拟
12-04
使用C模拟的操作系统以优先级为标准调度进程的算法，进程每调度一次优先级减1，同时剩余运行时间减1
C语言实现操作系统进程调度
12-20
2、进程调度算法模拟 先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度、时间片轮转调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。程序要考虑用户界面的友好性和使用方便性
进程调度模拟，自主选择调度算法（C语言实现）
05-29
NULL 博文链接：https://touch-2011.iteye.com/blog/1042338
操作系统综合性实验报告-进程调度(含代码).doc
12-22
在本实验报告中，我们关注的是如何通过编程模拟几种不同的进程调度算法，以加深对这些算法的理解。实验的主要目标是设计一个模拟程序，用C语言实现动态优先权调度、先来先服务（FCFS）、短进程优先（SPN）和时间片...
操作系统综合性实验报告材料-进程调度(含代码).doc
12-22
在本实验报告中，我们关注的是如何通过编程模拟几种常见的进程调度算法，以加深对这些算法的理解。以下是对实验涉及知识点的详细说明： 1. **进程**：进程是操作系统中的一个基本概念，它代表了程序的执行实例。每...
C语言实现单处理机调度算法研究
资源摘要信息:"单处理机调度_...总之，单处理机调度策略的设计与实现是操作系统课程中的一个重要部分，对于理解操作系统中进程调度的机制和原理具有重要意义。通过C语言的实践，可以加深对这些理论知识的理解和应用。
请帮我用c语言写出先到先服务调度算法FCFS
最新发布
10-13
在C语言中实现先到先服务（First-Come, First-Served，简称FCFS）调度算法，通常涉及到任务的队列操作。下面是一个简单的单线程FCFS调度示例： ```c #include <stdio.h> #include <stdlib.h> #include <time.h> typedef struct { int pid; // 进程ID int burst_time; // 进程运行时间 } Process; // 定义一个队列结构 typedef struct Queue { Process* queue; int front, rear; } Queue; void enqueue(Queue* q, Process p) { if (q->rear == q->front) { printf("Queue is full, can't add process %d\n", p.pid); return; } q->queue[q->rear] = p; q->rear++; } Process dequeue(Queue* q) { if (q->front == q->rear) { printf("Queue is empty, no process to dequeue\n"); return (Process){0, 0}; } Process p = q->queue[q->front]; q->queue[q->front] = NULL; q->front++; return p; } int main() { Queue system; system.queue = malloc(sizeof(Process)); system.front = system.rear = -1; // 创建一些进程并添加到队列 srand(time(0)); // 初始化随机数生成器 Process processes[4] = { {1, rand() % 10 + 1}, // 随机生成burst time {2, rand() % 10 + 1}, {3, rand() % 10 + 1}, {4, rand() % 10 + 1} }; for (int i = 0; i < 4; ++i) { enqueue(&system, processes[i]); } while (system.front != system.rear) { Process current_process = dequeue(&system); // 提取下一个进程 printf("Processing process %d with burst time %d...\n", current_process.pid, current_process.burst_time); // 模拟处理过程（这里只是简单打印，实际应用可能有更复杂的CPU模拟） sleep(current_process.burst_time); // 暂停当前进程的时间 printf("Finished processing process %d.\n", current_process.pid); } free(system.queue); return 0; } ``` 这个程序创建了一个队列，所有进程按照到达的顺序依次进入队列。`enqueue`函数用于将进程加入队列，`dequeue`函数用于取出并处理队首进程。在`main`函数中，我们循环地从队列中取出进程并让它们运行。 注意这只是一个基本的示例，并未涉及真正的并发或多线程，因为C标准库不支持原生的线程同步，如果需要在真实环境中实现多线程，可以考虑使用POSIX线程API或者其他线程库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天喜Studio

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值