深入理解任务调度

已于 2022-04-02 16:51:09 修改
阅读量479 收藏 3
点赞数 1
分类专栏： 操作系统 文章标签： 操作系统
于 2021-12-05 12:19:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/121727118
版权

一个有趣的问题

系统运行后，下面的任务将如何执行？

 我们期待的执行结果是 TaskA，TaskB，TaskC 在并行执行

我们可以看到 TaskB 并没有被执行

思考

任务B执行了吗？如果执行了，那么为什么看不到输出？

问题分析

app.c

void AppMain()
{
	RegApp("TaskA", TaskA, 255);
	RegApp("TaskB", TaskB, 255);
	RegApp("TaskC", TaskC, 255);
	//RegApp("TaskD", TaskD, 255);
}

task.c

#include "utility.h"
#include "task.h"
#include "app.h"

#define MAX_TASK_NUM       4
#define MAX_RUNNING_TASK   2
#define MAX_READY_TASK     (MAX_TASK_NUM - MAX_RUNNING_TASK)
#define MAX_TASK_BUFF_NUM  (MAX_TASK_NUM + 1)
#define PID_BASE           0x10

static AppInfo* (*GetAppToRun)(uint index) = NULL;
static uint (*GetAppNum)() = NULL;

void (* const RunTask)(volatile Task* pt) = NULL;
void (* const LoadTask)(volatile Task* pt) = NULL;

volatile Task* gCTaskAddr = NULL;
static TaskNode gTaskBuff[MAX_TASK_BUFF_NUM] = {0};
static TSS gTSS = {0};
static Queue gFreeTaskNode = {0};
static Queue gReadyTask = {0};
static Queue gRunningTask = {0};
static Queue gWaitingTask = {0};
static TaskNode* gIdleTask = NULL;
static uint gAppToRunIndex = 0;
static uint gPid = PID_BASE;

void TaskEntry()
{
	if(gCTaskAddr != NULL)
	{
		gCTaskAddr->tmain();
	}
	
	// to destory current task here
	asm volatile(
	    "movw $0, %ax \n"
	    "int $0x80 \n"
	);
	
	while(1);    // TODO: schedule next task to run
}

void IdleTask()
{  
    while(1);
}

static void InitTask(Task* pt, uint id, const char* name, void(*entry)(), ushort pri)
{
    pt->rv.cs = LDT_CODE32_SELECTOR;
    pt->rv.gs = LDT_VIDEO_SELECTOR;
    pt->rv.ds = LDT_DATA32_SELECTOR;
    pt->rv.es = LDT_DATA32_SELECTOR;
    pt->rv.fs = LDT_DATA32_SELECTOR;
    pt->rv.ss = LDT_DATA32_SELECTOR;
    
    pt->rv.esp = (uint)pt->stack + AppStackSize;
    pt->rv.eip = (uint)TaskEntry;
    pt->rv.eflags = 0x3202;
    
    pt->id = id;
    
    StrCpy(pt->name, name, sizeof(pt->name) - 1);
    
    pt->tmain = entry;
    
    pt->current = 0;
    pt->total = 256 - pri;
    
    SetDescValue(AddrOff(pt->ldt, LDT_VIDEO_INDEX),  0xB8000, 0x07FFF,         DA_DRWA + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_CODE32_INDEX), 0x00,    PageDirBase - 1, DA_C + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_DATA32_INDEX), 0x00,    PageDirBase - 1, DA_DRW + DA_32 + DA_DPL3);
    
    pt->ldtSelector = GDT_TASK_LDT_SELECTOR;
    pt->tssSelector = GDT_TASK_TSS_SELECTOR;
}

static void PrepareForRun(volatile Task* pt)
{
	pt->current++;

	gTSS.ss0 = GDT_DATA32_FLAT_SELECTOR;
    gTSS.esp0 = (uint)&pt->rv + sizeof(pt->rv);
    gTSS.iomb = sizeof(TSS);
    
    SetDescValue(AddrOff(gGdtInfo.entry, GDT_TASK_LDT_INDEX), (uint)&pt->ldt, sizeof(pt->ldt)-1, DA_LDT + DA_DPL0);
}

static void CreateTask()
{
	int num = GetAppNum();
	
	while((gAppToRunIndex < num) && (Queue_Length(&gReadyTask) < MAX_READY_TASK))
	{
		TaskNode* tn = (TaskNode*)Queue_Remove(&gFreeTaskNode);
		
		if(tn != NULL)
		{
			AppInfo* app = GetAppToRun(gAppToRunIndex);
			
			InitTask(&tn->task, gPid++, app->name, app->tmain, app->priority);
			
			Queue_Add(&gReadyTask, &tn->head);	
		}
		else
		{
			break;
		}
		
		gAppToRunIndex++;
	}
}

static void ReadyToRunning()
{
	QueueNode* node = NULL;

	if(Queue_Length(&gReadyTask) < MAX_READY_TASK)
	{
		CreateTask();
	}
	
	while((Queue_Length(&gReadyTask) > 0) && (Queue_Length(&gRunningTask) < MAX_RUNNING_TASK))
	{
		node = Queue_Remove(&gReadyTask);
		
		((TaskNode*)node)->task.current = 0;
		
		Queue_Add(&gRunningTask, node);
	}
}

static void RunningToReady()
{
	if(Queue_Length(&gRunningTask) > 0)
	{
		TaskNode* tn = (TaskNode*)Queue_Front(&gRunningTask);
	
		if(!IsEqual(tn, gIdleTask))
		{
			if(tn->task.current == tn->task.total)
			{
				Queue_Remove(&gRunningTask);
				Queue_Add(&gReadyTask, (QueueNode*)tn);
			}
		}
	}
}

static void CheckRunningTask()
{
	if(Queue_Length(&gRunningTask) == 0)
	{
		Queue_Add(&gRunningTask, &gIdleTask->head);
	}
	else if(Queue_Length(&gRunningTask) > 1)
	{
		if(Queue_Front(&gRunningTask) == &gIdleTask->head)
		{
			Queue_Remove(&gRunningTask);
		}
	}
}

void TaskModInit()
{
	int i = 0;
    byte* pStack = (byte*)(PageDirBase -  MAX_TASK_BUFF_NUM * AppStackSize);
    
    for(i = 0; i < MAX_TASK_BUFF_NUM; i++)
    {
    	TaskNode* tn = (void*)AddrOff(gTaskBuff, i);
    	
    	tn->task.stack = (void*)AddrOff(pStack, i * AppStackSize);
    }
    
    gIdleTask = (void*)AddrOff(gTaskBuff, MAX_TASK_NUM);
    
    GetAppToRun = (void*)(*((uint*)GetAppToRunEntry));
    GetAppNum = (void*)(*((uint*)GetAppNumEntry));
    
    Queue_Init(&gFreeTaskNode);
    Queue_Init(&gReadyTask);
    Queue_Init(&gRunningTask);
    Queue_Init(&gWaitingTask);
    
    for(i = 0; i < MAX_TASK_NUM; i++)
    {
    	Queue_Add(&gFreeTaskNode, (QueueNode*)AddrOff(gTaskBuff, i));
    }
    
    SetDescValue(AddrOff(gGdtInfo.entry, GDT_TASK_TSS_INDEX), (uint)&gTSS, sizeof(gTSS)-1, DA_386TSS + DA_DPL0);
    
    InitTask(&(gIdleTask->task), 0, "IdleTask", IdleTask, 255);
    
    ReadyToRunning();
    CheckRunningTask();
    
}

void LaunchTask()
{
    gCTaskAddr = &((TaskNode*)Queue_Front(&gRunningTask))->task;
    
    PrepareForRun(gCTaskAddr);
    
    RunTask(gCTaskAddr);
}

void Schedule()
{
	RunningToReady();
	
	ReadyToRunning();
	
	CheckRunningTask();

	Queue_Rotate(&gRunningTask);
	
    gCTaskAddr = &((TaskNode*)Queue_Front(&gRunningTask))->task;
    
    PrepareForRun(gCTaskAddr);
    
    LoadTask(gCTaskAddr);
}

void KillTask()
{
	QueueNode* node = Queue_Remove(&gRunningTask);
	
	Queue_Add(&gFreeTaskNode, node);
	
	Schedule();
}

TaskA，TaskB，TaskC 的 total 值都为1，任务开始被执行时，TaskA 和 TaskB 被放入执行队列，TaskA 的1次执行时间到了后，就把TaskA 移入到就绪队列，TaskC 加入到执行队列， 然后执行 Rotate 操作，将 TaskC 变换到执行队列的队首，去执行 TaskC，TaskC 的一次执行时间到了后，把 TaskC 移入到就绪队列， TaskA加入到执行队列，然后又执行 Rotate 操作，把 TaskA 变换到执行队列的队首，去执行 TaskA；TaskA 任务完成时，又把 TaskC 加入执行队列，执行 Rotate 操作，将 TaskC 变换到队首，去执行 TaskC，这样 TaskB 就永远无法得到执行了。

问题解决

任务B 得不到执行的关键是 要执行任务的 total 值不能都为1，所以我们需要将一个任务的最小 total 值设置为至少大于1。

task.c

#include "utility.h"
#include "task.h"
#include "app.h"

#define MAX_TASK_NUM       4
#define MAX_RUNNING_TASK   2
#define MAX_READY_TASK     (MAX_TASK_NUM - MAX_RUNNING_TASK)
#define MAX_TASK_BUFF_NUM  (MAX_TASK_NUM + 1)
#define PID_BASE           0x10
#define MAX_TIME_SLICE     260

static AppInfo* (*GetAppToRun)(uint index) = NULL;
static uint (*GetAppNum)() = NULL;

void (* const RunTask)(volatile Task* pt) = NULL;
void (* const LoadTask)(volatile Task* pt) = NULL;

volatile Task* gCTaskAddr = NULL;
static TaskNode gTaskBuff[MAX_TASK_BUFF_NUM] = {0};
static TSS gTSS = {0};
static Queue gFreeTaskNode = {0};
static Queue gReadyTask = {0};
static Queue gRunningTask = {0};
static Queue gWaitingTask = {0};
static TaskNode* gIdleTask = NULL;
static uint gAppToRunIndex = 0;
static uint gPid = PID_BASE;

void TaskEntry()
{
	if(gCTaskAddr != NULL)
	{
		gCTaskAddr->tmain();
	}
	
	// to destory current task here
	asm volatile(
	    "movw $0, %ax \n"
	    "int $0x80 \n"
	);
	
	while(1);    // TODO: schedule next task to run
}

void IdleTask()
{  
    while(1);
}

static void InitTask(Task* pt, uint id, const char* name, void(*entry)(), ushort pri)
{
    pt->rv.cs = LDT_CODE32_SELECTOR;
    pt->rv.gs = LDT_VIDEO_SELECTOR;
    pt->rv.ds = LDT_DATA32_SELECTOR;
    pt->rv.es = LDT_DATA32_SELECTOR;
    pt->rv.fs = LDT_DATA32_SELECTOR;
    pt->rv.ss = LDT_DATA32_SELECTOR;
    
    pt->rv.esp = (uint)pt->stack + AppStackSize;
    pt->rv.eip = (uint)TaskEntry;
    pt->rv.eflags = 0x3202;
    
    pt->id = id;
    
    StrCpy(pt->name, name, sizeof(pt->name) - 1);
    
    pt->tmain = entry;
    
    pt->current = 0;
    pt->total = MAX_TIME_SLICE - pri;
    
    gTSS.ss0 = GDT_DATA32_FLAT_SELECTOR;
    gTSS.esp0 = (uint)&pt->rv + sizeof(pt->rv);
    gTSS.iomb = sizeof(TSS);
    
    SetDescValue(AddrOff(pt->ldt, LDT_VIDEO_INDEX),  0xB8000, 0x07FFF,         DA_DRWA + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_CODE32_INDEX), 0x00,    PageDirBase - 1, DA_C + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_DATA32_INDEX), 0x00,    PageDirBase - 1, DA_DRW + DA_32 + DA_DPL3);
    
    pt->ldtSelector = GDT_TASK_LDT_SELECTOR;
    pt->tssSelector = GDT_TASK_TSS_SELECTOR;
}

static void PrepareForRun(volatile Task* pt)
{
	pt->current++;

	gTSS.ss0 = GDT_DATA32_FLAT_SELECTOR;
    gTSS.esp0 = (uint)&pt->rv + sizeof(pt->rv);
    gTSS.iomb = sizeof(TSS);
    
    SetDescValue(AddrOff(gGdtInfo.entry, GDT_TASK_LDT_INDEX), (uint)&pt->ldt, sizeof(pt->ldt)-1, DA_LDT + DA_DPL0);
}

static void CreateTask()
{
	int num = GetAppNum();
	
	while((gAppToRunIndex < num) && (Queue_Length(&gReadyTask) < MAX_READY_TASK))
	{
		TaskNode* tn = (TaskNode*)Queue_Remove(&gFreeTaskNode);
		
		if(tn != NULL)
		{
			AppInfo* app = GetAppToRun(gAppToRunIndex);
			
			InitTask(&tn->task, gPid++, app->name, app->tmain, app->priority);
			
			Queue_Add(&gReadyTask, &tn->head);	
		}
		else
		{
			break;
		}
		
		gAppToRunIndex++;
	}
}

static void ReadyToRunning()
{
	QueueNode* node = NULL;

	if(Queue_Length(&gReadyTask) < MAX_READY_TASK)
	{
		CreateTask();
	}
	
	while((Queue_Length(&gReadyTask) > 0) && (Queue_Length(&gRunningTask) < MAX_RUNNING_TASK))
	{
		node = Queue_Remove(&gReadyTask);
		
		((TaskNode*)node)->task.current = 0;
		
		Queue_Add(&gRunningTask, node);
	}
}

static void RunningToReady()
{
	if(Queue_Length(&gRunningTask) > 0)
	{
		TaskNode* tn = (TaskNode*)Queue_Front(&gRunningTask);
	
		if(!IsEqual(tn, gIdleTask))
		{
			if(tn->task.current == tn->task.total)
			{
				Queue_Remove(&gRunningTask);
				Queue_Add(&gReadyTask, (QueueNode*)tn);
			}
		}
	}
}

static void CheckRunningTask()
{
	if(Queue_Length(&gRunningTask) == 0)
	{
		Queue_Add(&gRunningTask, &gIdleTask->head);
	}
	else if(Queue_Length(&gRunningTask) > 1)
	{
		if(Queue_Front(&gRunningTask) == &gIdleTask->head)
		{
			Queue_Remove(&gRunningTask);
		}
	}
}

void TaskModInit()
{
	int i = 0;
    byte* pStack = (byte*)(PageDirBase -  MAX_TASK_BUFF_NUM * AppStackSize);
    
    for(i = 0; i < MAX_TASK_BUFF_NUM; i++)
    {
    	TaskNode* tn = (void*)AddrOff(gTaskBuff, i);
    	
    	tn->task.stack = (void*)AddrOff(pStack, i * AppStackSize);
    }
    
    gIdleTask = (void*)AddrOff(gTaskBuff, MAX_TASK_NUM);
    
    GetAppToRun = (void*)(*((uint*)GetAppToRunEntry));
    GetAppNum = (void*)(*((uint*)GetAppNumEntry));
    
    Queue_Init(&gFreeTaskNode);
    Queue_Init(&gReadyTask);
    Queue_Init(&gRunningTask);
    Queue_Init(&gWaitingTask);
    
    for(i = 0; i < MAX_TASK_NUM; i++)
    {
    	Queue_Add(&gFreeTaskNode, (QueueNode*)AddrOff(gTaskBuff, i));
    }
    
    SetDescValue(AddrOff(gGdtInfo.entry, GDT_TASK_TSS_INDEX), (uint)&gTSS, sizeof(gTSS)-1, DA_386TSS + DA_DPL0);
    
    InitTask(&(gIdleTask->task), 0, "IdleTask", IdleTask, 255);
    
    ReadyToRunning();
    CheckRunningTask();
    
}

void LaunchTask()
{
    gCTaskAddr = &((TaskNode*)Queue_Front(&gRunningTask))->task;
    
    PrepareForRun(gCTaskAddr);
    
    RunTask(gCTaskAddr);
}

void Schedule()
{
	RunningToReady();
	
	ReadyToRunning();
	
	CheckRunningTask();

	Queue_Rotate(&gRunningTask);
	
    gCTaskAddr = &((TaskNode*)Queue_Front(&gRunningTask))->task;
    
    PrepareForRun(gCTaskAddr);
    
    LoadTask(gCTaskAddr);
}

void KillTask()
{
	QueueNode* node = Queue_Remove(&gRunningTask);
	
	Queue_Add(&gFreeTaskNode, node);
	
	Schedule();
}

我们定义了宏 MAX_TIME_SLICE 最大时间分片为260，所以一个任务最少执行的次数为 (260 - 255 = 5)次，就不会出现一个在执行队列里的任务永远都无法被执行的情况了。

深入讨论

任务调度的定义

 当多个任务处于就绪状态，而处理器只有一个时，操作系统就必须决定哪一个任务先执行

操作系统中做出这种决定的部分称为调度器，调度器使用的算法为调度算法

关于调度算法的分类

非抢占式调度算法

  • 任务持续执行直到阻塞 (等待事件)，或自愿让出执行权

抢占式调度算法

  • 任务每次执行的时间固定，时间一到被迫让出执行权

什么时候进行任务调度？

当任务退出时 (运行结束)

当新任务创建时

当时钟中断发生时

当任务 I/O 中断发生时

任务的分类

计算密集型任务

  • 任务大部分时间在使用处理器运算 (如：科学运算)

I/O 密集型任务

  • 任务大部分时间用于等待 I/O 操作 (如：文件操作)

关于优先级调度

优先级用于反应任务的重要程度

优先级越高，任务越容易获得执行的机会

  • 越多的执行时间 (计算密集型任务)
  • 越快的响应速度 (I/O 密集型任务)

调度算法的终极目标

公平公正，每个任务都能被执行

最大化处理器利用率，保持处理器始终忙碌

最小化任务从执行到完成的时间

最快响应时间，快速响应用户交互

课后拓展

FCFS 先到先服务调度算法 (First Come First Served)

SJF 最短执行时间调度算法 (Shortest Job First)

RR 轮询调度算法 (Round Robin)

MQ 多级队列调度算法 (Multilevel Queue)

qq_52484093
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解DAG任务调度系统：核心原理与实现
禅与计算机程序设计艺术
12-27 2483
任务调度系统是计算机科学中一个重要的研究领域，它主要关注于在并行计算系统中有效地分配和调度任务的问题。任务调度系统的主要目标是在满足所有任务执行需求的前提下，最大化系统的资源利用率和任务执行效率。
任务调度(定时任务)
一个什么都不会的人
01-28 7631
任务调度、Java常见的任务调度方式、任务调度的问题、分布式任务调度平台
什么是任务调度
最新发布
分享博主日常学习和使用的一些技术
11-26 378
类比于linux里面的cron。
深入理解操作系统——cpu处理机调度详解
weixin_41186611的博客
07-31 428
无论当前执行的进程执行时间长度大于时间片长度或短于时间片长度，等到时间片时间结束时候，就会切换到下一进程执行，未执行完的进程继续等待排队。另外当计算机中有多个处理机的时候，每个处理机的调度算法可不相同，但要注意共享资源的访问要进行同步，进程分在哪个处理机上执行有静态和动态两种分配方式。处理机资源的使用模式是在时间片机制下，当当前时间片运行结束后，或者cpu在时间片未执行完之前被抢占时，这时候cpu得去决定去就绪队列里挑选下一个要执行的进程。将就绪队列划分为多个独立的子队列，分别有各自的调度算法。...
任务调度概述
weixin_30783629的博客
08-12 533
各种企业应用几乎都会遇到任务调度的需求，以论坛为例，每隔半小时生成精华文章的 RSS 文件，每天凌晨统计论坛用户的积分排名，每隔 30 分钟对锁定到期的用户进行解锁。对于一个典型的企业应用系统来说，每月1日凌晨统计上个月各部门的业务数据生成月报表，每隔半小时查询用户是否有快到期的待处理业务等，这样的例子俯拾皆是、不胜枚举。 以上所举调度场景的核心都是以时间为关注点的调度，即在特定的时间...
对调度任务的一点理解
weixin_36615286的博客
05-23 1225
在如今的企业级开发当中，Spring+Quartz整合实现定时任务调度是必不可少的，因此就在这做个简单的整理，方便日后查阅。●介绍 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz用一...
任务调度
Luowaterbi的博客
11-13 1363
任务调度 ①问题描述 多用户多任务操作系统中，多个任务同时共享计算机系统资源。为了使多个 任务均能够顺利执行，操作系统要按一定的原则对它们进行调度，使它们按一定 的次序进行。设只有一个 CPU，现有多个任务，它们需要 CPU 服务的时间已知。 在下列假设下，按平均等待时间最短为原则，设计算法求出任务的执行顺序。  忽略任务提交的时间差，即认为各任务同时提交。  各任务不同时提交。 ②...
status_pt-1.4.rar_产品调度_任务 调度_任务调度_任务调度 程序_状态机
09-22
《基于状态机的小型任务调度程序详解》 在IT领域，任务调度是系统管理的核心部分，它涉及到如何...对于那些想要深入了解任务调度或者正在寻找解决方案的开发者来说，深入研究这款程序及其背后的原理无疑将大有裨益。
sql server中的任务调度与CPU深入讲解
12-16
在SQL Server中，任务调度与CPU管理是数据库高效运行的关键环节。SQL Server 2005及后续版本引入了SQL Server Operating System (SQLOS)，这是一个介于SQL Server和Windows操作系统之间的中间层，专门用于处理资源...
Node.js-nodejs定时调度任务
08-09
nodejs定时调度任务
Node.js设置定时任务之node-schedule模块的使用详解
10-15
node-schedule是 Node.js 的一个定时任务（crontab）模块。这篇文章主要介绍了Node.js设置定时任务之node-schedule模块的使用,需要的朋友可以参考下
spring 任务调度
03-22
- **深入源码**：理解`@Scheduled`注解的处理流程，以及`TaskScheduler`如何调度任务，有助于优化和定制任务调度行为。 - **Quartz源码**：学习Quartz的工作原理，了解其内部调度机制，可以更好地利用其特性并解决...
基于windows的多任务调度代码.rar_windows多任务_任务 调度 C++_任务调度_多任务_多任务调度
09-21
为了深入理解这个示例，你需要分析源代码，关注如何初始化线程，如何管理线程间的同步（例如使用Mutex、Semaphore或Event对象），以及如何根据优先级调整任务的执行顺序。此外，学习和理解Windows API文档将有助于你...
任务调度的思考和总结
congbao6525的博客
03-31 329
我们就直接进入正题： 系统的crontab解决不了的几类问题： 任务的时间精度不够 ...
quartz任务调度简介
sayoko06的博客
08-23 341
quartz定时调度框架三个主要接口类 1、Job任务 具体要执行任务的程序。比如发短信，发邮件，访问数据库，同步数据，数据的清洗等业务逻辑功能。 2、Tigger触发器 　　作用: 它是来执行工作任务，在什么条件下触发，什么时间执行，多久执行一次。 　　四大类型：SimpleTrigger，CronTirgger，DateIntervalTrigger， 和 NthIncludedD...
Quartz任务调度简介---01
菜鸟在进步
08-02 219
1.特点： 强大的调度功能， 灵活的应用方式 分布式和集群能力 2.主要的设计模式： Builder模式，Factory模式，组件模式，链式写法
分布式任务调度相关介绍
beyond的博客
02-21 5165
分布式任务调度先介绍下：Spring&amp;amp;amp;SpringBoot任务调度工具传统定时任务存在的问题分布式环境里， 任务调度的困难及解决思想高可用任务调度原理 先介绍下：Spring&amp;amp;amp;SpringBoot任务调度工具 相信@Scheduled(cron = “0/5 * * * * ?”)这个注解大家都用过 实现原理：触发器 + 线程池 ==== 任务调度 下面例出几个式子 CRON表达...
在Node.js中实现任务调度与执行
热门推荐
chszs的专栏
05-08 1万+
在Node.js中实现任务调度与执行作者：chszs，未经博主允许不得转载。经许可的转载需注明作者和博客主页：http://blog.csdn.net/chszs批处理是业务开发中经常会遇到的需求，比如银行对账单的处理，又比如广告邮件的推送。Node.js在批处理方面也有一些优秀的库，node-schedule就是其中之一。node-schedule是一个轻量级的、基于Node.js的、类似于cro
深入理解Linux进程调度机制
"深入理解Linux进程调度机制" 在操作系统中，进程调度是核心功能之一，它决定了哪些进程能够获得CPU的执行权以及何时进行切换。Linux的进程调度机制旨在实现多任务并行处理，提高系统效率和用户体验。本文将详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值