多对一、一对一、多对多
多对一就是所说的“Green thread”，一个java应用程序
被当作一个任务被操作系统调度，而这个java应用程序里
的多个线程则由虚拟机调度执行。也可以说由虚拟机选出
一个多线程java程序里的一个线程作为活动线程，这个线
程再作为操作系统的一个任务被操作系统调度。
一对一就是一个java线程对应一个操作系统线程了，即同
一个多线程java程序里的所有线程都由操作系统统一调度。
多对多还不是很明白。。。
没java的 发段源代码给你 有兴趣自己慢慢理解#include <time.h>
#include <dos.h>
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <graphics.h>
#define ESC 0x1b
#define ENTER 0x0d
#define TRUE 1
#define FALSE 0
/*每隔TIME秒就变换一次优先级*/
#define TIME 5
/*数据结构*/
/****************************************************************/
enum _Status/*进程状态枚举*/
{
READY =0,/*就绪*/
RUN,/*执行中*/
SUSPEND,/*挂起*/
}
typedef enum _Status Status
/****************************************************************/
struct _Pcb/*进程结构*/
{
int PID/*进程ID，ID为负数的进程为系统后备队列的作业*/
int Time/*进程运行需要的时间*/
int Prior/*进程的优先级，越大越优先*/
Status Sts/*状态*/
struct _Pcb *Next/*指向本进程队列中下个进程的PCB*/
}
typedef struct _Pcb PCB
/****************************************************************/
struct _Batch/*多道处理中的道结构*/
{
PCB *pcb/*该道当前正在处理的进程*/
struct _Batch *Next/*下一道*/
}
typedef struct _Batch Batch
/****************************************************************/
/*多道系统相关全局变量*/
PCB *ProcQueue = NULL/*进程链表，按优先级从大到小排列*/
Batch *BatchQueue = NULL/*系统多道链表*/
/****************************************************************/
/*动态优先权抢占式调度算法及相关函数声明*/
/****************************************************************/
int InitBatchs(int n)/*初始化多道系统，n为道数*/
int InsertProc(int prior, int time)/*向进程链表中按优先级大小插入一个新进程*/
int InsertIDLE()/*向进程队列中加入后备进程，当系统空闲时将被调入*/
int SortProcQueue()/*将进程链表按优先级从大到小排列*/
int AddBatch()/*增加系统道数*/
int DeleteBatch()/*减少系统道数*/
int UnSuspendProc(int id)/*解除ID为id的进程的挂起状态*/
int UpdateBatchs()/*多道系统根据进程链表进行更新，并将执行完毕的进程删除*/
int PassSeconds(int n)/*系统经过n秒后计算数据并进行优先级调度*/
/****************************************************************/
/*各函数的定义*/
/****************************************************************/
int InitBatchs(int n)
{
int i
for (i=0i<n++i)
{
AddBatch()
}
return (UpdateBatchs())
}
int InsertProc(int prior, int time)
{
static int sysid = 0/*该系统已经加入过多少进程，此值将是新进程的ID*/
PCB *last,*now,*pcb
pcb = (PCB*)malloc(sizeof(PCB))
if (pcb == NULL) return FALSE
pcb->Prior = prior
pcb->Time = time
pcb->PID = (++sysid)
pcb->Sts = READY
if (ProcQueue == NULL)/*如果进程队列为空*/
{
ProcQueue = pcb
pcb->Next = NULL
return TRUE
}
last = ProcQueue
now = last->Next
if (pcb->Prior >last->Prior)/*pcb将排在队头*/
{
pcb->Next = ProcQueue
ProcQueue = pcb
return TRUE
}
while ((now != NULL) &&(pcb->Prior <now->Prior))/*寻找插入位置*/
{
last = now
now = last->Next
}
last->Next = pcb
pcb->Next = now
return TRUE
}
int InsertIDLE()
{
PCB *now = ProcQueue
PCB *idle = (PCB*)malloc(sizeof(PCB))
if (idle == NULL) return FALSE
idle->PID = -1
idle->Prior = -1
idle->Sts = SUSPEND
idle->Time = -1
idle->Next = NULL
if (ProcQueue == NULL)
{
ProcQueue = idle
return TRUE
}
while(now->Next != NULL)
{
now = now->Next
}
now->Next = idle
return TRUE
}
int SortProcQueue()
{ /*冒泡排序*/
PCB *last, *now
int b = FALSE/*上次遍历是否无交换产生*/
if (ProcQueue==NULL || ProcQueue->Next==NULL)/*如果链表中无进程或只有一个进程*/
return FALSE
while (!b)
{
b = TRUE
last=ProcQueue
now=last->Next
if (last->Prior <now->Prior)
{
ProcQueue = now
last->Next = now->Next
now->Next = last
b = FALSE
last = ProcQueue
now = last->Next
}
while (now->Next!=NULL)
{
if ((now->Prior)<(now->Next->Prior))
{
last->Next = now->Next
now->Next = now->Next->Next
last->Next->Next = now
b = FALSE
}
else
last = last->Next
now = last->Next
}
}
return TRUE
}
int AddBatch()
{
Batch *bt = (Batch*)malloc(sizeof(Batch))
if (bt==NULL) return FALSE
bt->Next = BatchQueue
BatchQueue = bt
bt->pcb = NULL
return (InsertIDLE())
}
int DeleteBatch()
{
Batch *bt = BatchQueue
PCB *last, *now
if (BatchQueue==NULL || BatchQueue->Next==NULL)/*如果只剩最后一道则不删除*/
return FALSE
if (ProcQueue==NULL || ProcQueue->Next==NULL)/*如果只有最后一个后备空闲进程*/
return FALSE/**/
last = ProcQueue
now = last->Next
while (now->Next != NULL)/*查找到最后一个进程，该进程必定是后备空闲进程*/
{
last = now
now = last->Next
}
if (now==NULL || now->PID>=0)/*未查找到后备进程*/
return FALSE/**/
free(now)
last->Next = NULL
BatchQueue = BatchQueue->Next
free(bt)
return TRUE
}
int UnSuspendProc(int id)
{
PCB *now = ProcQueue
if (ProcQueue==NULL) return FALSE
while (now != NULL)
{
if (now->PID == id)
{
now->Sts = READY
return TRUE
}
}
return FALSE
}
int UpdateBatchs()
{
Batch *bt = BatchQueue
PCB *last = ProcQueue, *now
while (bt != NULL)
{
bt->pcb = NULL
bt = bt->Next
}
if (ProcQueue == NULL) return TRUE
while (last->Sts==RUN &&last->PID>=0 &&last->Time<=0)
{
ProcQueue = ProcQueue->Next
free(last)
last = ProcQueue
}
now = last->Next
while (now != NULL)
{
if (now->Sts==RUN &&now->PID>=0 &&now->Time<=0)/*如果该进程是运行中的一般进程并已执行完毕*/
{
last->Next = now->Next
free(now)
}
else
last = last->Next
now = last->Next
}
bt = BatchQueue
now = ProcQueue
while (bt != NULL &&now != NULL)
{
bt->pcb = now
now->Sts = RUN
bt = bt->Next
now = now->Next
}
while (now != NULL)
{
if (now->Sts == RUN)
{
now->Sts = SUSPEND
}
now = now->Next
}
return TRUE
}
int PassSeconds(int n)
{
static int time = 0
int i=0, ProcEnd = FALSE
PCB *pcb = ProcQueue
Batch *bt = BatchQueue
if (bt == NULL) return FALSE
time += n
if (time>=TIME)
{
i = time/TIME/*经过多少时间段*/
time = time%TIME
}
while (bt != NULL)/*更新进程运行时间*/
{
if (bt->pcb->PID>=0)
{
bt->pcb->Time -= n
if (bt->pcb->Time <= 0)/*进程结束*/
{
ProcEnd = TRUE
}
}
bt = bt->Next
}
if (i >0)
{
while (pcb != NULL)/*更新进程优先权（动态优先权）*/
{
if (pcb->Sts == RUN &&pcb->PID>=0)/*运行的进程优先权降低*/
{
pcb->Prior -= i
if (pcb->Prior <0)
pcb->Prior = 0
}
else if (pcb->Sts == SUSPEND &&pcb->PID>=0)/*挂起的进程优先权升高*/
pcb->Prior += i
pcb = pcb->Next
}
}
if (i>0)
SortProcQueue()/*如果优先级有变动则重新排序*/
if (ProcEnd || i>0)
{
UpdateBatchs()/*更新多道进程*/
}
return TRUE
}
/****************************************************************/
/*图形界面相关函数*/
/****************************************************************/
/*表格的单位宽度和高度*/
#define WIDTH 64
#define HEIGHT 12
void *black=NULL/*背景色方格，使用它擦出表格中的图形*/
int InitGraph()/*初始化图形界面*/
{
intGraphDriver /* The Graphics device driver */
intGraphMode /* The Graphics mode value */
int ErrorCode
GraphDriver = DETECT /* Request auto-detection */
initgraph( &GraphDriver, &GraphMode, "" )
ErrorCode = graphresult() /* Read result of initialization*/
if( ErrorCode != grOk )
{ /* Error occured during init */
printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) )
getch()
return FALSE
}
cleardevice()
black = (void*)malloc(imagesize(1,1,WIDTH-1,HEIGHT-1))
getimage(1,1,WIDTH-1,HEIGHT-1,black)
DrawFrame()
DrawData()
return TRUE
}
int DrawFrame()/*画边框和表头*/
{
settextjustify(CENTER_TEXT, CENTER_TEXT)
gprintf(320, HEIGHT/2-1, "Multi-Batch System Emulation")
settextjustify(LEFT_TEXT, TOP_TEXT)
moveto(0,HEIGHT)
lineto(0,479)
lineto(639,479)
lineto(639,HEIGHT)
lineto(0,HEIGHT)
line(WIDTH*4,HEIGHT,WIDTH*4,479)
line(WIDTH*7,HEIGHT,WIDTH*7,479)
line(0,HEIGHT*2,639,HEIGHT*2)
line(0,HEIGHT*3,639,HEIGHT*3)
gprintf(HEIGHT*0+2,HEIGHT*1+2,"System Batchs")/*系统多道列表头*/
gprintf(HEIGHT*0+2,HEIGHT*2+2,"Batch")
gprintf(WIDTH*1+2,HEIGHT*2+2,"ProcID")
gprintf(WIDTH*2+2,HEIGHT*2+2,"Time")
gprintf(WIDTH*3+2,HEIGHT*2+2,"Prior")
gprintf(WIDTH*4+2,HEIGHT*1+2,"Suspended Processes")/*挂起队列列表头*/
gprintf(WIDTH*4+2,HEIGHT*2+2,"ProcID")
gprintf(WIDTH*5+2,HEIGHT*2+2,"Time")
gprintf(WIDTH*6+2,HEIGHT*2+2,"Prior")
gprintf(WIDTH*7+2,HEIGHT*1+2,"Ready Processes")/*就绪队列列表头*/
gprintf(WIDTH*7+2,HEIGHT*2+2,"ProcID")
gprintf(WIDTH*8+2,HEIGHT*2+2,"Time")
gprintf(WIDTH*9+2,HEIGHT*2+2,"Prior")
}
int DrawData()/*绘制系统数据*/
{
int numRun=0, numSus=0, numRed=0/*运行挂起和就绪的进程各有多少*/
PCB* now = ProcQueue
int x=0, y=0
while (now != NULL)
{
switch(now->Sts)
{
case RUN:
x = WIDTH*1
y = HEIGHT*(3+(numRun++))
break
case SUSPEND:
x = WIDTH*4
y = HEIGHT*(3+(numSus++))
break
case READY:
x = WIDTH*7
y = HEIGHT*(3+(numRed++))
break
}
if (now->Sts==RUN)/*该进程为正在运行的进程*/
{
putimage(x-WIDTH+1,y+1,black,COPY_PUT)
gprintf(x-WIDTH+2,y+2,"%d",numRun)
}
if (now->PID>=0)/*该进程不是后备进程*/
{
putimage(x+1,y+1,black,COPY_PUT)
gprintf(x+2,y+2,"%d",now->PID)
putimage(x+1+WIDTH,y+1,black,COPY_PUT)
gprintf(x+WIDTH+2,y+2,"%d",now->Time)
putimage(x+1+WIDTH*2,y+1,black,COPY_PUT)
gprintf(x+WIDTH*2+2,y+2,"%d",now->Prior)
}
else
{
putimage(x+1,y+1,black,COPY_PUT)
putimage(x+1+WIDTH,y+1,black,COPY_PUT)
putimage(x+1+WIDTH*2,y+1,black,COPY_PUT)
gprintf(x+2,y+2,"system idle process")
}
now = now->Next
}
}
int DlgGetNum(char *buf,int l,int t,int r,int b,int gettime)
{
char ch
int pos=0
bar(l,t,r,b)
gprintf(l+10,t+5,"Add new Process")
if (gettime)
gprintf(l+10,t+20,"input the time:")
else
gprintf(l+10,t+20,"input the priority:")
while (1)
{
ch = getch()
if (ch == ENTER)/*如果输入了回车键*/
{
if(pos!=0)/*如果位置不在第一位(回车键不准第一个输入)*/
{
buf[pos]='\0'
break
}
}
else if (ch>='0' &&ch<='9')
{
buf[pos++]=ch
buf[pos]='\0'
}
else if (ch == ESC)
{
return FALSE
}
else/*其他按键均按BackSpace处理*/
{
--pos
buf[pos]='\0'
}
if (pos<0)
{ pos=0buf[pos]='\0'}
else if (pos>4)/*最多输入4位数*/
{ pos=4buf[pos]='\0'}
bar(l,t+35,r,t+47)
gprintf(l+50,t+35,buf)
}
return TRUE
}
int NewProcDlg()
{
int l=200,t=150,r=380,b=200,pos=0,prior=0,time=0
char buf[5],ch
PCB *pcb
void* bg = (void*)malloc(imagesize(l,t,r,b))
getimage(l,t,r,b,bg)
setfillstyle(1,2)
flushall()
/*******输入优先级**********/
if (!DlgGetNum(buf,l,t,r,b,FALSE))
goto exit
prior = atoi(buf)
/*******输入时间**********/
pos=0
buf[pos]='\0'
if (!DlgGetNum(buf,l,t,r,b,TRUE))
goto exit
time = atoi(buf)
InsertProc(prior, time)
exit:
putimage(l,t,bg,COPY_PUT)
free(bg)
return TRUE
}
int gprintf( int xloc, int yloc, char *fmt, ... )/*图形系统中的格式输出*/
{
va_list argptr /* Argument list pointer */
char str[140] /* Buffer to build sting into */
int cnt /* Result of SPRINTF for return */
va_start( argptr, format ) /* Initialize va_ functions */
cnt = vsprintf( str, fmt, argptr )/* prints string to buffer */
outtextxy( xloc, yloc, str )/* Send string in graphics mode */
va_end( argptr ) /* Close va_ functions */
return( cnt ) /* Return the conversion count */
}
/****************************************************************/
/*main函数*/
int main()
{
clock_t start=0, end=0
char kb
InitBatchs(3)/*初始化为3道系统*/
InitGraph()
while (1)
{
start = end = clock()
while (!kbhit())
{
start = clock()
if ((start-end)/18.2 >= 1)/*时间过了一秒*/
{
start = end = clock()
PassSeconds(1)
cleardevice()
DrawFrame()
DrawData()
}
}
kb = getch()
switch (kb)
{
case ESC:
closegraph()
return 0
case 'w':
AddBatch()
UpdateBatchs()
cleardevice()
DrawFrame()
DrawData()
break
case 's':
DeleteBatch()
UpdateBatchs()
cleardevice()
DrawFrame()
DrawData()
break
case 'i':
NewProcDlg()
UpdateBatchs()
DrawFrame()
DrawData()
break
}
}
return 0
}
公众:类PrivilegeProcess {公共静态无效的主要(字串[] args){
MyQueue的MyQueue的新MyQueue的()/ /声明队列
印刷电路板[PCB = {新的PCB(001 ，8,1)，新的PCB(002,7,9)，新的PCB(003,3,8)，新的PCB(004,1,7)，新的PCB(005,7,4)}
>PCB段=新的PCB()
(INT I = 0<pcb.length+ +){/ /初始化先进行排序，选择排序这里使用的是高优先级的一线队
(J =我<pcb.lengthJ + +){
(PCB [I]。特权<PCB [J]。特权){
段= PCB [1]
PCB [I] = PCB [J]
PCB [J] =段
}
}
}
体系。通过out.println(“入队后第一时间的进程的顺序:”)
(INT I = 0<pcb.length+ +){
的System.out调用println(第一次入队#程序名称:“+ PCB [我]。名称+ totaltime:”+ PCB [I]。totaltime +“的”特权“+ PCB [我]。特权)}
()
myqueue.start(PCB)
}
}
类MyQueue的{
INT指数= 0
PCB [] PC =新的PCB [5]
PCB [] PC1 =新的PCB [4]
PCB温度=新的PCB() BR />公共无效排队(PCB工艺){/ /排队算法
(指数== 5){
(“出界!”)
返回
}
PC [索引] =进程
指数+ +
}
公共:PCB DEQUEUE(){/ /出队算法(索引== 0)
返回空
(INT I = 0<pc1.length+ +){
PC1 [I] = PC [ +1]
}
指数 -
温度= PC [0]
(INT I = 0<pc1.length+ +){ BR />PC [I] = PC1 [I]
}
回报条件
}
公共无效启动(PCB [] PC){/ /进程表算法
(PC [0]。isNotFinish ==真| | PC [1 isNotFinish ==真| | PC [2 isNotFinish ==真| | PC [3]。时isNotFinish ==真| | PC [4]。isNotFinish ==){
/ / *注:| |运算符都是假的，所有的表达式结果为假，否则真
(INT I = 0<PC长度+ +){
PC [I]。运行(这一点)/>} 的System.out.println()
(INT I = 0<pc.length+ +){/ /处理每个运行一次运行的时间片的长度重新排序优先一旦
(J =我<pc.lengthJ + +){
如果(PC [I]特权<PC [J]。特权){
温度= PC [I]
PC [I] = PC [J]
PC [J] =温度
}
}
}
}
}
}
类PCB {/ /声明过程级
和int名，totaltime ，运行时特权
布尔isNotFinish的
公众PCB(){
}
公开PCB(名称，诠释totaltime特权){
this.name =的名称/ /进程名
this.totaltime = totaltime / /
this.privilege =特权/ /总时间优先 this.runtime = 2 / /时间片值是2
this.isNotFinish =真/ /是否执行完成
(“初始值:程序名称:”+名+“totaltime:”+ totaltime +“特权”+特权)
System.out的。调用println()
}
MyQueue的MQ公共无效的run(){/ /处理的基础上实施的时间片算法
(totalTime>1){ totaltime =运行/ /总时间大于1，总时间=总时间 - 时间片
特权 -
(“程序名称:”+姓名+“ remaintime:“+ +”特权“+特权)totaltime
的} else if(totaltime == 1){
totaltime - / /总时间为1时，执行时间为1
>特权 -
(“程序名称:”+姓名+“remaintime:”+ totaltime +“特权”+特权)
}其他{
isNotFinish =假/ / 0，将isNotFinish标志设置为假
}
如果(isNotFinish ==真){br mq.deQueue() mq.enQueue(本)}
}
}
