操作系统课程设计nachosProject1源代码

Task1修改KThreadpackagenachos.threads;importnachos.machine.*;publicclassKThread{ publicKThread(Runnabletarget){ this();//调用无参数的构造器 this.target=target; } publicKThread(){ booleanstatus=Merrupt().disable(); if(currentThread!=null){ tcb=newTCB(); }else{ currentThread=this; tcb=TCB.currentTCB();//第一个线程是主线程，指向第一个TCB name="main"; readyQueue=ThreadedKernel.scheduler.newThreadQueue(false); readyQueue.acquire(this); restoreState();//对主线程置运行状态 createIdleThread(); } waitQueue.acquire(this); Merrupt().restore(status); } publicvoidfork(){//执行KThread Lib.assertTrue(status==statusNew); Lib.assertTrue(target!=null); Lib.debug(dbgThread,"Forkingthread:"+toString()+"Runnable:" +target); booleanintStatus=Merrupt().disable();//关中断，在线程将要执行的准备阶段不能被打断 tcb.start(newRunnable(){ publicvoidrun(){ runThread();//方法内有target } }); ready();//并未真正开始执行，只是将线程移动到ready队列 Merrupt().restore(intStatus);//回到机器原来的状态，就好似生成线程这件事从没发生过 } privatevoidrunThread(){ begin(); target.run();//执行target finish(); } privatevoidbegin(){ Lib.debug(dbgThread,"Beginningthread:"+toString()); Lib.assertTrue(this==currentThread); restoreState(); Merrupt().enable();//开中断 } publicstaticvoidfinish(){ Lib.debug(dbgThread,"Finishingthread:"+currentThread.toString()); Merrupt().disable();//关中断 Machine.autoGrader().finishingCurrentThread();//将TCB变成将要结束的TCB Lib.assertTrue(toBeDestroyed==null); toBeDestroyed=currentThread;//将当前线程变为将要结束的线程，下一个线程运行的时候自动消除它 currentThread.status=statusFinished;//当前线程状态置为完成 KThreadthread=currentThread().waitQueue.nextThread(); if(thread!=null) { thread.ready(); } sleep();//将当前线程置为完成态，读取下一个就绪线程 } publicstaticvoidsleep(){//如果线程执行完，那么是从finish来，否那么线程锁死，读取下一个线程 Lib.debug(dbgThread,"Sleepingthread:"+currentThread.toString()); Lib.assertTrue(Merrupt().disabled()); if(currentThread.status!=statusFinished) currentThread.status=statusBlocked; runNextThread(); } privatestaticvoidrunNextThread(){//执行下一个线程 KThreadnextThread=readyQueue.nextThread(); if(nextThread==null) nextThread=idleThread;//如果线程队列为空那么执行idle线程 nextThread.run(); } privatevoidrun(){ Lib.assertTrue(Merrupt().disabled()); Machine.yield();//当前java线程放弃CPU currentThread.saveState();//无实际操作 Lib.debug(dbgThread,"Switchingfrom:"+currentThread.toString() +"to:"+toString()); currentThread=this; tcb.contextSwitch(); currentThread.restoreState(); } publicstaticvoidyield(){//运行线程放弃cpu，将当前线程放入就绪队列，读取就绪队列下一个线程运行 Lib.debug(dbgThread,"Yieldingthread:"+currentThread.toString()); Lib.assertTrue(currentThread.status==statusRunning); booleanintStatus=Merrupt().disable(); currentThread.ready();//正在执行的线程放入就绪队列，执行就绪队列的下一个线程 runNextThread();//运行下一个线程 Merrupt().restore(intStatus); } publicvoidready(){//将线程移动到ready队列 Lib.debug(dbgThread,"Readythread:"+toString()); Lib.assertTrue(Merrupt().disabled()); Lib.assertTrue(status!=statusReady); status=statusReady; if(this!=idleThread){ readyQueue.waitForAccess(this); }//将线程移入队列，idle线程不用放入等待队列 Machine.autoGrader().readyThread(this);//空方法 } privatestaticvoidcreateIdleThread(){//创立idle线程 Lib.assertTrue(idleThread==null); idleThread=newKThread(newRunnable(){ publicvoidrun(){ while(true) yield(); }//idle线程一直执行的操作是yield〔放弃〕 }); idleThread.setName("idle"); Machine.autoGrader().setIdleThread(idleThread);//空方法 idleThread.fork(); } protectedvoidrestoreState(){//恢复状态，执行此线程，如果有要结束的线程就结束它 Lib.debug(dbgThread,"Runningthread:"+currentThread.toString()); Lib.assertTrue(Merrupt().disabled()); Lib.assertTrue(this==currentThread); Lib.assertTrue(tcb==TCB.currentTCB()); Machine.autoGrader().runningThread(this); status=statusRunning; if(toBeDestroyed!=null){ toBeDestroyed.tcb.destroy(); toBeDestroyed.tcb=null; toBeDestroyed=null; } } publicvoidjoin(){//线程B中有A.join()语句，那么B等A执行完才能执行 Lib.debug(dbgThread,"Joiningtothread:"+toString()); Lib.assertTrue(this!=currentThread); Lib.assertTrue(join_counter==0); join_counter++; booleanstatus=Merrupt().disable(); if(this.status!=statusFinished){ waitQueue.waitForAccess(KThread.currentThread()); currentThread.sleep(); } Merrupt().restore(status); } publicstaticKThreadcurrentThread(){//返回当前KThread Lib.assertTrue(currentThread!=null); returncurrentThread; } privatestaticclassPingTestimplementsRunnable{ PingTest(intwhich){ this.which=which; } publicvoidrun(){ for(inti=0;i<5;i++){ System.out.println("***thread"+which+"looped"+i +"times"); currentThread.yield();//每次执行一次就让权 } } privateintwhich; } publicstaticvoidselfTest(){//检测是否工作正常 Lib.debug(dbgThread,"EnterKThread.selfTest"); // newKThread(newPingTest(1)).setName("forkedthread").fork();// newPingTest(0).run();// selfTest_join();// selfTest_Condition2();// selfTest_Alarm();// selfTest_Communicator();// selfTest_Boat();// selftest_Scheduler(); selftest_LotteryScheduler(); } publicstaticvoidselfTest_join(){//检测join是否工作正常 Lib.debug(dbgThread,"EnterKThread.selfTest"); System.out.println("______jointestbegin_____"); finalKThreadthread1=newKThread(newPingTest(1)); thread1.setName("forkedthread").fork(); newKThread(newRunnable(){ publicvoidrun(){ thread1.join(); currentThread.yield(); System.out.println("successful"); } }).fork(); } publicstaticvoidselfTest_Condition2(){//检测Condition2是否工作正常 Lib.debug(dbgThread,"EnterKThread.selfTest"); System.out.println("______Condition2testbegin_____"); finalLocklock=newLock(); finalCondition2condition2=newCondition2(lock); newKThread(newRunnable(){ publicvoidrun(){ lock.acquire();//线程执行之前获得锁 KThread.currentThread().yield(); condition2.sleep(); System.out.println("thread1executing"); condition2.wake(); lock.release();//线程执行完毕将锁释放 System.out.println("thread1executesuccessful"); } }).fork(); newKThread(newRunnable(){ publicvoidrun(){ lock.acquire();//线程执行之前获得锁 KThread.currentThread().yield(); condition2.wake(); System.out.println("thread2executing"); condition2.sleep(); lock.release();//线程执行完毕将锁释放 System.out.println("thread2executesuccessful"); } }).fork(); } publicstaticvoidselfTest_Alarm(){//检测Alarm是否工作正常 newKThread(newRunnable(){ publicvoidrun(){ System.out.println(Machine.timer().getTime()); ThreadedKernel.alarm.waitUntil(500); System.out.println(Machine.timer().getTime()); System.out.println("successful"); } }).fork(); } publicstaticvoidselfTest_Communicator(){//检测Communicator是否工作正常 Lib.debug(dbgThread,"EnterKThread.selfTest"); System.out.println("______Communicatortestbegin_____"); finalCommunicatorcommunicator=newCommunicator(); newKThread(newRunnable(){ publicvoidrun(){ communicator.speak(20); System.out.println("thread1successful"); } }).fork(); newKThread(newRunnable(){ publicvoidrun(){ communicator.speak(30); System.out.println("thread2successful"); } }).fork(); newKThread(newRunnable(){ publicvoidrun(){ System.out.println(communicator.listen()); System.out.println("thread3successful"); } }).fork(); newKThread(newRunnable(){ publicvoidrun(){ System.out.println(communicator.listen()); System.out.println("thread4successful"); } }).fork(); } publicstaticvoidselfTest_Boat(){//检测join是否工作正常 Lib.debug(dbgThread,"EnterKThread.selfTest"); System.out.println("______Boattestbegin_____"); newKThread(newRunnable(){ publicvoidrun(){ Boat.selfTest(); System.out.println("successful"); } }).fork(); } publicstaticvoidselftest_Scheduler(){ finalKThreadthread1=newKThread(newRunnable(){ publicvoidrun(){ for(inti=0;i<3;i++) {KThread.currentThread().yield(); System.out.println("thread1");} } }); KThreadthread2=newKThread(newRunnable(){ publicvoidrun(){ for(inti=0;i<3;i++) {KThread.currentThread().yield(); System.out.println("thread2");} } }); KThreadthread3=newKThread(newRunnable(){ publicvoidrun(){ thread1.join(); for(inti=0;i<3;i++) {KThread.currentThread().yield(); System.out.println("thread3");} } }); booleanstatus=Merrupt().disable(); ThreadedKernel.scheduler.setPriority(thread1,2); ThreadedKernel.scheduler.setPriority(thread2,4); ThreadedKernel.scheduler.setPriority(thread3,6); thread1.setName("thread111"); thread2.setName("thread2222"); thread3.setName("thread33333"); Merrupt().restore(status); thread1.fork();thread2.fork(); thread3.fork(); } publicstaticvoidselftest_LotteryScheduler(){ finalKThreadthread1=newKThread(newRunnable(){ publicvoidrun(){ for(inti=0;i<3;i++) {KThread.currentThread().yield(); System.out.println("thread1");} } }); KThreadthread2=newKThread(newRunnable(){ publicvoidrun(){ for(inti=0;i<3;i++) {KThread.currentThread().yield(); System.out.println("thread2");} } }); KThreadthread3=newKThread(newRunnable(){ publicvoidrun(){ thread1.join(); for(inti=0;i<3;i++) {KThread.currentThread().yield(); System.out.println("thread3");} } }); booleanstatus=Merrupt().disable(); ThreadedKernel.scheduler.setPriority(thread1,1); ThreadedKernel.scheduler.setPriority(thread2,2); ThreadedKernel.scheduler.setPriority(thread3,7); thread1.setName("thread111"); thread2.setName("thread2222"); thread3.setName("thread33333"); Merrupt().restore(status); thread1.fork();thread2.fork(); thread3.fork(); } publicKThreadsetTarget(Runnabletarget){//设置target，返回自身 Lib.assertTrue(status==statusNew); this.target=target; returnthis; } publicKThreadsetName(Stringname){//设置名字，返回自身 =name; returnthis; } publicStringgetName(){//返回名字 returnname; } publicStringtoString(){//返回名字和自身标识 return(name+"(#"+id+")"); } publicintcompareTo(Objecto){//通过比拟标识符来比拟线程大小 KThreadthread=(KThread)o; if(id<thread.id) return-1; elseif(id>thread.id) return1; else return0; } protectedvoidsaveState(){ Lib.assertTrue(Merrupt().disabled()); Lib.assertTrue(this==currentThread); } privateintjoin_counter=0; privateintstatus=statusNew;//进程状态，一开始均为新的 privateStringname="(unnamedthread)"; privateRunnabletarget; privateTCBtcb; privateintid=numCreated++;//每个KThread都有唯一的标识 privatestaticintnumCreated=0;//标识从0开始 //进程状态 privatestaticfinalintstatusNew=0; privatestaticfinalintstatusReady=1; privatestaticfinalintstatusRunning=2; privatestaticfinalintstatusBlocked=3; privatestaticfinalintstatusFinished=4; privatestaticThreadQueuereadyQueue=null;//就绪队列 privateThreadQueuewaitQueue=ThreadedKernel.scheduler.newThreadQueue(true); privatestaticKThreadcurrentThread=null; privatestaticKThreadtoBeDestroyed=null; privatestaticKThreadidleThread=null; privatestaticfinalchardbgThread='t'; /** *Additionalstateusedbyschedulers. * *@see */ publicObjectschedulingState=null;}Task2修改Condition2packagenachos.threads;importnachos.machine.*;/***Animplementationofconditionvariablesthatdisablesinterrupt()sfor*synchronization.**<p>*Youmustimplementthis.**@see*/publicclassCondition2{/***Allocateanewconditionvariable.**@param conditionLock thelockassociatedwiththiscondition* variable.Thecurrentthreadmustholdthis* lockwheneverituses<tt>sleep()</tt>,* <tt>wake()</tt>,or<tt>wakeAll()</tt>.*/publicCondition2(LockconditionLock){ this.conditionLock=conditionLock; waitqueue=ThreadedKernel.scheduler.newThreadQueue(false);}/***Atomicallyreleasetheassociatedlockandgotosleeponthiscondition*variableuntilanotherthreadwakesitusing<tt>wake()</tt>.The*currentthreadmustholdtheassociatedlock.Thethreadwill*automaticallyreacquirethelockbefore<tt>sleep()</tt>returns.*/publicvoidsleep(){ Lib.assertTrue(conditionLock.isHeldByCurrentThread());booleanstatus=Merrupt().disable(); conditionLock.release();waitqueue.waitForAccess(KThread.currentThread());KThread.currentThread().sleep();//返回就是有线程使用wake唤醒这个线程了 conditionLock.acquire();//重新获得锁才能执行 Merrupt().restore(status);}/***Wakeupatmostonethreadsleepingonthisconditionvariable.The*currentthreadmustholdtheassociatedlock.*/publicvoidwake(){ Lib.assertTrue(conditionLock.isHeldByCurrentThread()); booleanstatus=Merrupt().disable(); KThreadthread=waitqueue.nextThread(); if(!(thread==null)) thread.ready();//只是将线程参加就绪队列，但不释放锁 Merrupt().restore(status); }/***Wakeupallthreadssleepingonthisconditionvariable.Thecurrent*threadmustholdtheassociatedlock.*/publicvoidwakeAll(){ Lib.assertTrue(conditionLock.isHeldByCurrentThread()); booleanstatus=Merrupt().disable(); KThreadthread=waitqueue.nextThread(); while(!(thread==null)) {thread.ready(); thread=waitqueue.nextThread(); } Merrupt().restore(status); }privateLockconditionLock;privateThreadQueuewaitqueue=null;}Task3修改Alarm类packagenachos.threads;importjava.util.LinkedList;importjava.util.ListIterator;importnachos.machine.*;publicclassAlarm{ publicAlarm(){ Machine.timer().setInterruptHandler(newRunnable(){ publicvoidrun(){ timerInterrupt(); } }); } publicvoidtimerInterrupt(){//产生时间中断，将时间符合的线程放入ready队列以便执行 booleanstatus=Merrupt().disable(); longcurrenttime=Machine.timer().getTime(); intsize=linkedlist.size(); if(size==0) ; else for(inti=0;i<size;i++){ if(currenttime<linkedlist.get(i).getWakeTime()) ; else{ KThreadthread=linkedlist.get(i).getThread(); thread.ready(); linkedlist.remove(i); size--; i=0; currenttime=Machine.timer().getTime(); } } KThread.currentThread().yield(); Merrupt().restore(status); } publicvoidwaitUntil(longx){//将线程与时间结合放入一个有序链表，线程休眠 booleanstatus=Merrupt().disable(); longwaketime=Machine.timer().getTime()+x; KThreadWakeTimekthreadwaketime=newKThreadWakeTime( KThread.currentThread(),waketime); intsize=linkedlist.size(); if(size==0) linkedlist.add(kthreadwaketime); else for(inti=0;i<size;i++){ if(waketime<linkedlist.get(i).getWakeTime()){ linkedlist.add(i,kthreadwaketime); break; } if(i==size-1 &&waketime>=linkedlist.get(i).getWakeTime()) linkedlist.add(i+1,kthreadwaketime); } KThread.currentThread().sleep(); Merrupt().restore(status); } publicclassKThreadWakeTime{ privateKThreadthread=null; privatelongwaketime=0; publicKThreadWakeTime(KThreadthread,longwaketime){ this.thread=thread; this.waketime=waketime; } publicKThreadgetThread(){ returnthread; } publiclonggetWakeTime(){ returnwaketime; } } LinkedList<KThreadWakeTime>linkedlist=newLinkedList();}Task4修改Communicatorpackagenachos.threads;importjava.util.*;importnachos.machine.*;publicclassCommunicator{publicCommunicator(){ lock=newLock(); queue=newLinkedList<Integer>(); speaker=newCondition2(lock); listener=newCondition2(lock); word=0; speakercount=0; listenercount=0;}publicvoidspeak(intword){//如果有听者，说者直接说话，然后返回，否那么，说者等待 booleanintStatus=Merrupt().disable(); lock.acquire(); if(listenercount==0){ speakercount++; queue.offer(word);speaker.sleep();listener.wake();speakercount--;} else {queue.offer(word); listener.wake(); }lock.release();Merrupt().restore(intStatus);return; }publicintlisten(){//如果有说者，让说者说话，得到word，听者返回word，否那么听者等待 booleanintStatus=Merrupt().disable(); lock.acquire(); if(speakercount!=0) { speaker.wake(); listener.sleep(); } else {listenercount++; listener.sleep(); listenercount--; } lock.release(); Merrupt().restore(intStatus); returnqueue.poll();}privateLocklock;privateCondition2speaker,listener;privateintword,speakercount,listenercount;privateQueue<Integer>queue;}5修改PrioritySchedulerpackagenachos.threads;importnachos.machine.*;importjava.util.LinkedList;importjava.util.TreeSet;importjava.util.HashSet;importjava.util.Iterator;publicclassPrioritySchedulerextendsScheduler{publicPriorityScheduler(){}publicThreadQueuenewThreadQueue(booleantransferPriority){//分配一个线程队列 returnnewPriorityQueue(transferPriority);}publicintgetPriority(KThreadthread){//得到线程的优先级 Lib.assertTrue(Merrupt().disabled()); returngetThreadState(thread).getPriority();}publicintgetEffectivePriority(KThreadthread){//得到线程的有效优先级 Lib.assertTrue(Merrupt().disabled()); returngetThreadState(thread).getEffectivePriority();}publicvoidsetPriority(KThreadthread,intpriority){//设置线程优先级 Lib.assertTrue(Merrupt().disabled()); Lib.assertTrue(priority>=priorityMinimum&& priority<=priorityMaximum); getThreadState(thread).setPriority(priority);}publicbooleanincreasePriority(){//增加运行线程的优先级 booleanintStatus=Merrupt().disable(); KThreadthread=KThread.currentThread(); intpriority=getPriority(thread); if(priority==priorityMaximum) returnfalse; setPriority(thread,priority+1); Merrupt().restore(intStatus); returntrue;}publicbooleandecreasePriority(){//降低运行线程的优先级 booleanintStatus=Merrupt().disable(); KThreadthread=KThread.currentThread(); intpriority=getPriority(thread); if(priority==priorityMinimum) returnfalse; setPriority(thread,priority-1); Merrupt().restore(intStatus); returntrue;}/***Thedefaultpriorityforanewthread.Donotchangethisvalue.*/publicstaticfinalintpriorityDefault=1;//新线程默认优先级publicstaticfinalintpriorityMinimum=0;//线程最低优先级是0publicstaticfinalintpriorityMaximum=7;//线程最高优先级是7/***Returntheschedulingstateofthespecifiedthread.**@param thread thethreadwhoseschedulingstatetoreturn.*@return theschedulingstateofthespecifiedthread.*/protectedThreadStategetThreadState(KThreadthread){//得到线程的优先级状态，如果线程优先级未创立那么创立为默认优先级 if(thread.schedulingState==null) thread.schedulingState=newThreadState(thread); return(ThreadState)thread.schedulingState;}/***A<tt>ThreadQueue</tt>thatsortsthreadsbypriority.*/protectedclassPriorityQueueextendsThreadQueue{//优先级队列类，继承自线程队列 PriorityQueue(booleantransferPriority){//自动调用父类无参数构造方法，创立一个线程队列 this.transferPriority=transferPriority; } publicvoidwaitForAccess(KThreadthread){//传入等待队列的线程 Lib.assertTrue(Merrupt().disabled()); getThreadState(thread).waitForAccess(this); } publicvoidacquire(KThreadthread){ Lib.assertTrue(Merrupt().disabled()); if(!thread.getName().equals("main")) { getThreadState(thread).acquire(this); } } publicKThreadnextThread(){ Lib.assertTrue(Merrupt().disabled()); //implementme intmax=-1; index=0; ThreadStatestate=null,temp=null; while((temp=pickNextThread())!=null) { if(temp.getEffectivePriority()>max) { state=temp; max=temp.getEffectivePriority(); } } if(state==null) { returnnull; } else { returnwaitQueue.remove(waitQueue.indexOf(state)).thread; } } /** *Returnthenextthreadthat<tt>nextThread()</tt>wouldreturn, *withoutmodifyingthestateofthisqueue. * *@return thenextthreadthat<tt>nextThread()</tt>would * return. */ protectedThreadStatepickNextThread(){ //implementme if(index<waitQueue.size()) { index++; returnwaitQueue.get(index-1);} returnnull; } publicvoidprint(){ Lib.assertTrue(Merrupt().disabled()); //implementme(ifyouwant) } /** *<tt>true</tt>ifthisqueueshouldtransferpriorityfromwaiting *threadstotheowningthread. */ publicbooleantransferPriority; publicLinkedList<ThreadState>waitQueue=newLinkedList<ThreadState>(); publicThreadStatelinkedthread=null; privateintindex;}protectedclassThreadState{ publicThreadState(KThreadthread){ this.thread=thread; setPriority(priorityDefault);waitQueue=newPriorityQueue(true); } publicintgetPriority(){ returnpriority; } publicintgetEffectivePriority(){//得到有效优先级 //implementme effectivepriority=-1; for(inti=0;i<waitQueue.waitQueue.size();i++) { if(waitQueue.waitQueue.get(i).getEffectivePriority()>effectivepriority) effectivepriority=waitQueue.waitQueue.get(i).getEffectivePriority(); } if(effectivepriority>priority) setPriority(effectivepriority); returnpriority; } publicvoidsetPriority(intpriority){//优先级传递 if(this.priority==priority) return; this.priority=priority; //implementme } publicvoidwaitForAccess(PriorityQueuewaitQueue){//将此线程状态存入传入的等待队列 //implementme waitQueue.waitQueue.add(this); if(waitQueue.linkedthread!=null&&waitQueue.linkedthread!=this) { waitQueue.linkedthread.waitQueue.waitForAccess(this.thread); } } publicvoidacquire(PriorityQueuewaitQueue){//相当于一个线程持有的队列锁 //implementme Lib.assertTrue(waitQueue.waitQueue.isEmpty()); waitQueue.linkedthread=this; } protectedKThreadthread;//这个对象关联的线程 protectedintpriority;//关联线程的优先级 protectedinteffectivepriority;//有效优先级 protectedPriorityQueuewaitQueue; }}Task6修改Boatpackagenachos.threads;importnachos.ag.BoatGrader;publicclassBoat{ staticBoatGraderbg; privatestaticKThreadparentThread;//父进程 privatestaticintchildren_number_Oahu;//在Oahu岛上孩子的数量 privatestaticintadult_number_Oahu;//在Oahu岛上成人的数量 privatestaticintchildren_number_Molokai;//在Molokai岛上孩子的数量 privatestaticintadult_number_Molokai;//在Molokai岛上成人的数量 privatestaticConditionchildren_condition_Oahu;//孩子在Oahu岛上的条件变量 privatestaticConditionchildren_condition_Molokai;//孩子在Molokai岛上的条件变量 privatestaticConditionadult_condition_Oahu;//成人在Oahu岛上的条件变量 privatestaticLocklock; privatestaticbooleanis_adult_go;//判断是否该成人走 privatestaticbooleanboat_in_Oahu;//判断船是否在Oahu privatestaticbooleanis_pilot;//判断现在的孩子是不是驾驶员 privatestaticbooleanis_end;//判断运送是否结束 publicstaticvoidselfTest(){ BoatGraderb=newBoatGrader(); //System.out.println("\n***TestingBoatswithonly2children***"); //begin(0,2,b); //System.out.println("\n***TestingBoatswith2children,1adult***"); //begin(1,2,b); //System.out.println("\n***TestingBoatswith3children,3adults***"); begin(3,3,b); } publicstaticvoidbegin(intadults,intchildren,BoatGraderb){ bg=b; parentThread=KThread.currentThread(); for(inti=0;i<adults;i++) newKThread(newRunnable(){ publicvoidrun(){ AdultItinerary(); } }).fork(); for(inti=0;i<children;i++) newKThread(newRunnable(){ publicvoidrun(){ ChildItinerary(); } }).fork(); children_number_Oahu=children; adult_number_Oahu=adults; children_number_Molokai=0; adult_number_Molokai=0;