Producer & Consumer ---- a practice in concurrent simulation

import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Write implements Runnable {
    private WriteAndRead writeAndRead;
    private int p = 0;
    private int count = 0;

    Write(WriteAndRead wr) {
        writeAndRead = wr;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (writeAndRead.numbers[p] != null)
                        wait();
                }
                synchronized (writeAndRead.read) {
                    System.out.println("write");
                    writeAndRead.numbers[p] = p;
                    p = (p + 1) % 8;
                    ++count;
                    writeAndRead.read.notifyAll();
                    TimeUnit.MILLISECONDS.sleep(100);
                }
                if (count > WriteAndRead.END)
                    throw new InterruptedException();
            }
        } catch (InterruptedException e) {
            System.out.println("write interrupted.");
        }
    }
}

class Read implements Runnable {
    private WriteAndRead writeAndRead;
    private int p = 0;
    private int count = 0;

    Read(WriteAndRead wr) {
        writeAndRead = wr;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (writeAndRead.numbers[p] == null) {
                        wait();
                    }
                }

                System.out.println("read ");
                TimeUnit.MILLISECONDS.sleep(100);
                synchronized (writeAndRead.write) {
                    System.out.println(writeAndRead.numbers[p]);
                    writeAndRead.numbers[p] = null;
                    p = (p + 1) % 8;
                    ++count;
                    writeAndRead.write.notifyAll();
                }
                if (count == WriteAndRead.END) {
                    System.out.println("end");
                    writeAndRead.exce.shutdownNow();
                    throw new InterruptedException();
                }
            }

        } catch (InterruptedException e) {
            System.out.println("read interrupted.");
        }
    }
}


class WriteAndRead {
    final Write write = new Write(this);
    final Read read = new Read(this);
    Integer[] numbers = new Integer[8];
    static final int END = 3;
    ExecutorService exce = Executors.newCachedThreadPool();

    WriteAndRead() {
        Arrays.fill(numbers, null);
        exce.execute(write);
        exce.execute(read);
    }

    public static void main(String[] args) {
        new WriteAndRead();
    }
}