Nachos java版学习（一）

    最近，操作系统课程设计使用伯克利大学的Nachos做为实验平台，老师也照搬伯克利的Project要求，开始我们的操作系统课程设计。

    结合自己的学习过程和课设要求，我觉得对Nachos的学习首先应该从KThread.java入手,首先应该看明白这个类的所有函数的意思。

     这个主要是为第一个proj，实现join（）函数做准备。 Join()方法的含义：当前线程a在运行，执行b.join(),则a阻塞，直到线程b结束，a继续执行。

     具体的要求有：Join函数的作用即为等待某线程运行完毕。当前线程 (唯一一个正在运行的线程) A调用另一个线程 (处于就绪状态) B的join函数时 (A 和 B 在Nachos中均为KThread类型对象)，A被挂起，直到B运行结束后， join函数返回，A才能继续运行。注意在一个KThread对象上只能调用一次join，且当前线程不能对自身调用join。Waits for this thread to finish. If this thread is already finished, return immediately. This method must only be called once; the second call is not guaranteed to return. This thread must not be the current thread.

    

public void join() {

        Lib.debug(dbgThread, "Joining to thread: " + toString());
        // 等待另外一个线程结束的这个线程不能是线程自己
        Lib.assertTrue(this != currentThread);

        if (this.status == statusFinished)
            return;

        boolean intStatus = Machine.interrupt().disable();

        if (joinQueue == null) {
            joinQueue = ThreadedKernel.scheduler.newThreadQueue(true);
            // Notify this thread queue that a thread has received access,without going through request() and nextThread()
            joinQueue.acquire(this);
        }
        // Notify this thread queue that the specified thread is waiting for
        // access
        joinQueue.waitForAccess(currentThread);
        KThread.sleep();
        Machine.interrupt().restore(intStatus);
    }

 

      为此，我设置了一个KThread的队列joinQueue，当B调用join函数时，将正在执行的A线程放入joinQueue，只有在B执行完后，在finish()里面会将队列中的A线程状态变为ready，从而继续执行A线程，具体finish()实现的代码如下：

public static void finish() {
        Lib.debug(dbgThread, "Finishing thread: " + currentThread.toString());

        Machine.interrupt().disable();

        Machine.autoGrader().finishingCurrentThread();

        Lib.assertTrue(toBeDestroyed == null);
        toBeDestroyed = currentThread;

        currentThread.status = statusFinished;

        KThread joinedKThread;
        if (currentThread.joinQueue != null)
            while ((joinedKThread = currentThread.joinQueue.nextThread()) != null)
                joinedKThread.ready();
        sleep();
    }

 后续测试程序如下：

package nachos.threads;

import nachos.machine.*;

public class KThreadTest {

    public KThreadTest() {
    }

    public static void simpleJoinTest() {
        KThread A_thread = new KThread(new KThreadTest.A_thread(5));
        KThread B_thread = new KThread(new KThreadTest.B_thread(A_thread));
        B_thread.fork();
        B_thread.join();
    }

    public static class B_thread implements Runnable {
        B_thread(KThread joinee) {
            this.joinee = joinee;
        }

        public void run() {
            System.out.println("B_thread 就绪");
            System.out.println("Forking and joining A_thread...");
            this.joinee.fork();//Causes this thread to begin execution.
            this.joinee.join();//启动a线程，阻塞b线程
            System.out.println("B_thread 执行结束");
        }

        private KThread joinee;
    }

    public static class A_thread implements Runnable {
        A_thread(int num) {
            this.num = num;
        }

        public void run() {
            System.out.println("A_thread 就绪");
            System.out.println("A_thread开始执行");

            // This should just kill some cycles
            for (int i = 0; i < this.num; ++i) {
                System.out.println("A_thread 循环 第" + i + " 次");
                KThread.currentThread().yield();
            }
            System.out.println("A_thread 执行结束");
        }
        private int num;
    }
    
}