多级反馈队列算法

有些瑕疵，但也勉强够用了

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
	
int T = 10;//单位时间片长度

typedef struct process
{
	int id;
	int time;
	int needtime;//剩余时间
}process;

typedef struct queue
{
	int priority;//优先级
	int timechip;//时间片
	process queue[10];//队列
}queue;

void qinit(queue* q, int len);//就绪队列初始化
void enter(process n, queue* q);//进程n入队
process quit(queue* q);//取出队列中首个非空进程
int isempty(queue* q);//判断队列是否为空
int isfull(queue* q);//判断队列是否满
double uniform(double a, double b, long int* seed);//产生均匀分布随机数

int main()
{
	long int seed = rand();
	queue q[4];
	qinit(q, 4);

	int t = 0;//单位时间起始
	int id = 0;//进程id起始
	int cpu = 0;//cpu是否被占用
	int time_to_free_cpu = 0;//cpu占用解除的时间

	while (1)
	{
		t++;//单位时间增加
		if (t == time_to_free_cpu)
		{
			cpu = 0;
		}//cpu占用时间结束
		
		double r;
		if (r = uniform(0, 1, &seed) >= 0.99 && !isfull(&q[0]) && !isfull(&q[1]) && !isfull(&q[2]) && !isfull(&q[3]))
		{
			process p;
			p.id = ++id;
			p.needtime = (int)uniform(1, 17.0 * T, &seed);
			p.time = p.needtime;/*(0.3 * uniform(0, 1.0 * T, &seed) + 0.3 * uniform(0, 2.0 * T, &seed) + 0.2 * uniform(0, 4.0 * T, &seed) + 0.2 * uniform(0, 8.0 * T, &seed));*/
			enter(p, &q[0]);
		}//每一个单位时间内均有0.25的概率产生新进程，其可在第一个队列未满时入队
		if (cpu == 0)//cpu未被占用
		{
			if (!isempty(&q[0]))
			{
				cpu = 1;//cpu被占用
				process n = quit(&q[0]);
				time_to_free_cpu = t + min(q[0].timechip, n.needtime);

				if (q[0].timechip < n.needtime)
				{
					n.needtime -= q[0].timechip;
					enter(n, &q[1]);
				}//在第一轮里面没有处理完，则进入第二个队列
				else
				{
					printf("进程id=%d，需要时间%d，于t=%d时处理完毕\n", n.id, n.time, time_to_free_cpu);
				}
			}
			else if (!isempty(&q[1]))
			{
				cpu = 1;//cpu被占用
				process n = quit(&q[1]);
				time_to_free_cpu = t + min(q[1].timechip, n.needtime);

				if (q[1].timechip < n.needtime)
				{
					n.needtime -= q[1].timechip;
					enter(n, &q[2]);
				}//在第二轮里面没有处理完，则进入第三个队列
				else
				{
					printf("进程id=%d，需要时间%d，于t=%d时处理完毕\n", n.id, n.time, time_to_free_cpu);
				}
			}
			else if (!isempty(&q[2]))
			{
				cpu = 1;//cpu被占用
				process n = quit(&q[2]);
				time_to_free_cpu = t + min(q[2].timechip, n.needtime);

				if (q[2].timechip < n.needtime)
				{
					n.needtime -= q[2].timechip;
					enter(n, &q[3]);
				}//在第三轮里面没有处理完，则进入第四个队列
				else
				{
					printf("进程id=%d，需要时间%d，于t=%d时处理完毕\n", n.id, n.time, time_to_free_cpu);
				}
			}
			else if (!isempty(&q[3]))
			{
				cpu = 1;//cpu被占用
				process n = quit(&q[3]);
				time_to_free_cpu = t + min(q[3].timechip, n.needtime);

				if (q[3].timechip < n.needtime)
				{
					n.needtime -= q[3].timechip;
					enter(n, &q[3]);
				}//在第四轮里面没有处理完，则在第四个队列里面继续
				else
				{
					printf("进程id=%d，需要时间%d，于t=%d时处理完毕\n", n.id, n.time, time_to_free_cpu);
				}
			}
		}
	}

	return 0;
}

double uniform(double a, double b, long int* seed)
{
	double t;
	*seed = 2045 * (*seed) + 1;
	*seed = (*seed) % 1048576;
	t = (*seed) / 1048576.0;
	t = a + (b - a) * t;
	return (t);
}

void qinit(queue* q, int len)
{
	for (int i = 0; i < len; i++)
	{
		q[i].priority = i + 1;
		for (int j = 0; j < 10; j++)
		{
			q[i].queue[j].time = q[i].queue[j].needtime = q[i].queue[j].id = 0;
		}
		q[i].timechip = T * pow(2, i);
	}
}//初始化就绪队列

process quit(queue* q)
{
	process temp;
	for (int i = 9; i >= 0; i--)
	{
		if (q->queue[i].id != 0)
		{
			temp = q->queue[i];
			q->queue[i].time = q->queue[i].needtime = q->queue[i].id = 0;
			return temp;
			break;
		}
	}
}

void enter(process n, queue* q)
{
	for (int i = 9; i > 0; i--)
	{
		q->queue[i] = q->queue[i - 1];
	}
	q->queue[0] = n;
}

int isfull(queue* q)
{
	if (q->queue[9].id != 0)
	{
		return 1;
	}
	return 0;
}

int isempty(queue* q)
{
	if (q->queue[0].id == 0)
	{
		return 1;
	}
	return 0;
}

/*
虽然改进的大部分问题，但仍然存在优先级较低的队列里后进队的进程将之前的进程挤掉的情况发生
*/