Java wait/notify 不在线程中调用

Question

我在调度两个线程(ReadData 和 WriteData)时遇到问题。好像等了之后也通知不了。这是我定义和调用的类:

Buffer:我用来读/写数据的缓冲区。我同步这个类。

public class Buffer {
    // Size of buffer we use to store data
    public static final int SIZE = 10;

    // Data of buffer.
    private int[] values;

    // Count of element in data.
    private int count;

    // Instance of buffer, for singleton pattern 
    private static Buffer instance = null;

    // A signal show data in use (busy) or not
    private static Object mutex = new Object();

    // Constructor of buffer
    private Buffer(){
        values = new int[SIZE];
        count = 0;
    }

    // Get instance of buffer.
        public static  Buffer getInstance(){
            if(instance == null){
                synchronized (mutex) {
                    if(instance == null) instance = new Buffer();
                }           
            }
            return instance;
        }


        public void addValue(int value){
            synchronized (mutex) {
                if(count >= SIZE) return;

                values[count++] = value;
            }
        }

        // Return current data and then reset buffer.
        public int[] getValues(){
            synchronized (mutex) {
                if(count == 0) return null;

                int[] values = new int[count];
                System.arraycopy(this.values, 0, values, 0, count);
                count = 0;
                return values;
            }
        }

        public int getCount(){
            synchronized (mutex) {
                return count;
            }
        }
}

ReadData:我用这个类将数据存储到缓冲区中。

import java.util.Random;

public class ReadData implements Runnable {
    Buffer buffer = Buffer.getInstance();

    @Override
    public synchronized void run() {
        Random random = new Random();
        while(true){
            if(buffer.getCount() >= Buffer.SIZE){
                try {
                    System.out.println("Read: is waiting. . .");
                    mState.readIsWaiting();
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println("Read: storing data");
                buffer.addValue(random.nextInt(Buffer.SIZE) + 1);
            }
        }

    }

    public interface ReadState{
        void readIsWaiting();
    }

    private ReadState mState;

    public void setReadState(ReadState state){
        mState = state;
    }

    public synchronized void makeNotify() {
        notifyAll();        
    }

}

WriteData:我用这个类从缓冲区获取数据

 public class WriteData implements Runnable {
        Buffer buffer = Buffer.getInstance();

        @Override
        public synchronized void run() {
            while(true){
                if(buffer.getCount() == 0){
                    try {
                        System.out.println("Write: is waiting. . .");
                        mState.writeIsWaiting();
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    int[] getdata = buffer.getValues();
                    System.out.println("first data: " + getdata[0]);
                }
            }

        }

        public interface WriteState{
            void writeIsWaiting();
        }

        private WriteState mState;

        public void setWriteState(WriteState state){
            mState = state;
        }

        public synchronized void makeNotify() {
            notifyAll();        
        }
    }

MyThread:我用来启动读/写的线程

package main;

import testing.ReadData;
import testing.WriteData;


public class MyThread implements ReadData.ReadState, WriteData.WriteState  {
    private ReadData read;
    private WriteData write;

    public void start(){
        read = new ReadData();
        write = new WriteData();
        read.setReadState(this);
        write.setWriteState(this);
        new Thread(read).start();
        new Thread(write).start();
    }

    @Override
    public void writeIsWaiting() {
        read.makeNotify();

    }

    @Override
    public void readIsWaiting() {
        write.makeNotify();

    }

}

就是这样。有时它会起作用，但很多时候它会停下来等待。我该如何解决这个问题？谢谢

Answer 1

我认为您已经用 WriteData 反转了 ReadData 实现。在所示代码中，如果缓冲区已满，ReadData 线程将阻塞:

@Override
public synchronized void run() {
    Random random = new Random();
    while(true){
        if(buffer.getCount() >= Buffer.SIZE){
            try {
                System.out.println("Read: is waiting. . .");
                mState.readIsWaiting();
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("Read: storing data");
            buffer.addValue(random.nextInt(Buffer.SIZE) + 1);
        }
    }

}

你真正需要的是:

@Override
public synchronized void run() {
    Random random = new Random();
    while(true){
        if(buffer.getCount() == 0){
            try {
                System.out.println("Read: is waiting. . .");
                mState.readIsWaiting();
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("Read: storing data");
            buffer.addValue(random.nextInt(Buffer.SIZE) + 1);
        }
    }

}

类似地，在 WriteData 实现中，如果缓冲区已满，则应该阻塞。如果读者没有机会从缓冲区中获取元素，就会发生这种情况。这应该适用于 WriteData 代码:

    @Override
    public synchronized void run() {
        while(true){
            if(buffer.getCount() >= Buffer.SIZE){
                try {
                    System.out.println("Write: is waiting. . .");
                    mState.writeIsWaiting();
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                int[] getdata = buffer.getValues();
                System.out.println("first data: " + getdata[0]);
            }
        }

    }