nachos-java Task1.4 Communicator

Task 1.4 Communicator

• 实验要求
• 实验关键代码
• 关键代码分析
• 实验测试代码
• 测试结果分析

实验要求

◆ Implement synchronous send and receive of one word messages
– using condition variables (don’t use semaphores!)
– Implement the Communicator class with operations

• void speak(int word)

• int listen()

◆ speak() atomically waits until listen() is called on the same Communicator object, and then transfers the word over to listen(). Once the transfer is made, both can return

◆ listen() waits until speak() is called, at which point the transfer is made, and both can return (listen() returns the word)

◆ This means that neither thread may return from listen() or speak() until the word transfer has been made.

◆ Your solution should work even if there are multiple speakers and listeners for the same Communicator

实验关键代码

变量声明

Lock lock;
private int speakerNum;
private int listenerNum;
private LinkedList<Integer> words;
Condition2 listener;
Condition2 speaker;

方法实现

关键代码是peak(int word)方法和listen()方法。

Void speak(int word)方法：

public void speak(int word) {
    boolean preState = Machine.interrupt().disable();
    lock.acquire();
    words.add(word);
    if(listenerNum == 0){
        speakerNum++;
        System.out.println("暂时没有收听者，等待收听");
        speaker.sleep();
        listenerNum--;
    }else{
         speakerNum++;
         listener.wake();
         listenerNum--;
    }
    lock.release();
    Machine.interrupt().restore(preState);

Int listen()方法：

public int listen() {
    boolean preState = Machine.interrupt().disable();
    lock.acquire();
    if(speakerNum==0){
        listenerNum++;
        System.out.println("暂时没有说话者，等待说话");
        listener.sleep();
        speakerNum--;
    }else{
        listenerNum++;
        speaker.wake();
        speakerNum--;   
    }
    lock.release();
    Machine.interrupt().restore(preState);
    return words.removeLast();
}

实验测试代码

private static class Speaker implements Runnable {
    private Communicator c;
    Speaker(Communicator c) {
        this.c = c;
    }
    public void run() {
        for (int i = 0; i < 5; ++i) {
            System.out.println("speaker speaking" + i);
            c.speak(i);
            //System.out.println("speaker spoken");
            KThread.yield();
        }
    }
}
public static void SpeakTest() {
    System.out.println("测试Communicator类：");
    Communicator c = new Communicator();
    new KThread(new Speaker(c)).setName("Speaker").fork();
    for (int i = 0; i < 5; ++i) {
        System.out.println("listener listening " + i);
        int x = c.listen();
        System.out.println("listener listened, word = " + x);
        KThread.yield();
    }
}

关键代码分析

思路分析

本实验编写程序并不难，重点在理解这个问题的本质：缓冲区为0的生产者消费者问题。说者说话只要有听者就交流成功，否则阻塞等待听者；听者听话只要有说者就交流成功，否则阻塞等待说者说话。

方法解释

1、Void Speak ( int word)方法

先申请锁，将说的话存放在words链表中，并将说者人数加1；然后判断是否有听者，如果没有，则说者睡眠；唤醒后要将听者人数减1;如果有听者，则将听者唤醒，然后将听者人数减1;记得最后将锁释放。

2、int listen()方法

先申请锁，将听着人数加1，然后判断是否有说者，如果没有，则听者睡眠，唤醒后要将说者人数减1；如果有，则将说者唤醒，并将说者人数减1；最后记得将锁释放，并返回words里一条信息。

关键点和难点

关键点：理解什么时候人数增加或减少。
每次说者讲话，不管有没有听者，说者人数先加一；减一操作在每次听者将说者唤醒之后；听者人数变化同理，每次听话，不管有没有说者，人数先加一，减一操作在每次说者唤醒听者之后。

难点：如何避免听者和说者在同时执行：可使用一把互斥锁。

测试结果分析

测试结果截图

测试结果分析

测试方法共使用两个线程，一个线程调用5次speak(int word)方法，另一个线程调用5次listen()方法，从而模拟了多个听者与说者的问题，从测试结果看，听者先听，发现没有说者，则听者睡眠；说者说话，唤醒听者，交流成功。