Consumer-Producer Problem

　　This is the 4th assignment of EI328, in which we are required to simulate Consumer-Producer Problem with a multi-threading program. A main thread puts integers ranging from 1 to 100 into a bounded buffer, and meanwhile 5 working threads fetch integers from the buffer and print them on the terminal.

　　Here is the source code that I submitted at the time:

import java.util.concurrent.*;

class BoundedQueue {
    private int size;
    private int front, rear;
    private int[] arr;
    
    public BoundedQueue (int size) {
        this.size = size+1;
        arr = new int[this.size];
    }
    public boolean isFull() {
        return (rear+1)%size==front;
    }
    public boolean isEmpty() {
        return rear==front;
    }
    public void add(int k) {
        rear = (rear+1)%size;
        arr[rear] = k;
    }
    public int poll() {
        front = (front+1)%size;
        return arr[front];
    }
}


class Producer extends Thread {
    public static BoundedQueue buffer;
    
    public Producer() {
        buffer = new BoundedQueue(10);
        start();
    }
    public void run() {
        try {
            int elem = 0;
            while (elem<100) {
                Main.bufferMutex.acquire();
                if (!buffer.isFull()) {
                    buffer.add(++elem);
                }
                Main.bufferMutex.release();
            }
            Main.flag = true;
        } catch (Exception e) {
            System.err.println("Error: "+e);
        }
    }
}

class Consumer extends Thread{
    private int idx;
    
    public Consumer(int idx) {
        this.idx = idx;
        start();
    }
    public void run() {
        int data = 0;
        try {
            while (true) {
                // Extract a number from the buffer
                Main.bufferMutex.acquire();
                boolean empty = Producer.buffer.isEmpty();
                if (!empty) {
                    data = Producer.buffer.poll();
                } 
                Main.bufferMutex.release();
                if (!empty) {
                    // Print the number on the console
                    Main.consoleMutex.acquire();
                    System.out.print(this+":	");
                    System.out.println(data);
                    Main.consoleMutex.release();
                    // Work outside the critical section
                    TimeUnit.MILLISECONDS.sleep(100);
                }
                // Judge whether to quit
                if (Main.flag && empty) {
                    break;
                } 
            }
        } catch (Exception e) {
            System.err.println("Error: "+e);
        }
    }
    public String toString() {
        return "WorkThread_"+idx;
    }
}

public class Main {
    public static Semaphore bufferMutex;
    public static Semaphore consoleMutex;
    public static boolean flag;
    
    public static void main(String[] args) {
        bufferMutex = new Semaphore(1);
        consoleMutex = new Semaphore(1);
        Producer p = new Producer();
        Consumer[] c = new Consumer[5];
        for (int i=0;i<5;i++) {
            c[i] = new Consumer(i+1);
        }
        try {
            for (int i=0;i<5;i++) {
                c[i].join();
            }
            p.join();
        } catch (Exception e) {
            System.err.println("Error: "+e);
        }
    }
}

　　Nevertheless, my program did not won TA's approval, for the reason that when the buffer is full or empty there will be busy waiting threads that waste CPU time. A good solution requires at least two more semaphores that indicate the buffer is full and empty respectively.

　　However, simply adding two more semaphores full and empty may result in a dilemma where the producer has finished his work whereas all the consumers are still waiting besides an empty buffer. To tackle this problem, I use a sentinel as a message passed from the producer to consumers. When the producer has put all the products in the buffer, he will put into buffer one more special product. This product, as a sentinel, can be recognized by any consumer who happens to fetch it, and such a consumer will put it back into the buffer (as a message for his fellows) and then terminate the loop.

　　Here is my revised solution to this problem, where I made a simple blocking queue as the bounded buffer.

import java.util.concurrent.*;

class BoundedQueue {
    private int[] arr;
    private int size;
    private int front, rear;
    private Semaphore mutex;
    private Semaphore full;
    private Semaphore empty;
    
    public BoundedQueue (int size) {
        this.size = size+1;
        arr = new int[this.size];
        mutex = new Semaphore(1);
        full = new Semaphore(1);
        empty = new Semaphore(0);
    }
    public boolean isFull() {
        return (rear+1)%size==front;
    }
    public boolean isEmpty() {
        return rear==front;
    }
    public void add(int k) {
        try {
            full.acquire();
            mutex.acquire();
            rear = (rear+1)%size;
            arr[rear] = k;
            mutex.release();
            empty.release();
        } catch (Exception e) {
            System.err.println("Error: "+e);
        }
    }
    public int poll() {
        int val = -1;
        try {
            empty.acquire();
            mutex.acquire();
            front = (front+1)%size;
            val = arr[front];
            mutex.release();
            full.release();
        } catch (Exception e) {
            System.err.println("Error: "+e);
        }
        return val;
    }
}

class Producer extends Thread {
    private BoundedQueue buffer;
    
    public Producer() {
        buffer = Main.buffer;
        start();
    }
    public void run() {
        try {
            int elem = 0;
            while (elem<100) {
                buffer.add(++elem);
            }
            Thread.sleep(10);
            buffer.add(-1);
        } catch (Exception e) {
            System.err.println("Error 1: "+e);
        }
    }
}

class Consumer extends Thread{
    private BoundedQueue buffer;
    private int idx;
    
    public Consumer(int idx) {
        buffer = Main.buffer;
        this.idx = idx;
        start();
    }
    public void run() {
        int data = 0;
        try {
            while (true) {
                data = buffer.poll();
                if (data<0) {
                    buffer.add(data);
                    break;
                } else {
                    Main.console.acquire();
                    System.out.print(this+":	");
                    System.out.println(data);
                    Main.console.release();
                }
            }
        } catch (Exception e) {
            System.err.println("Error 2: "+e);
        }
    }
    public String toString() {
        return "WorkThread_"+idx;
    }
}

public class Main {
    public static BoundedQueue buffer;
    public static Semaphore console;
    
    public static void main(String[] args) {
        console = new Semaphore(1);
        buffer = new BoundedQueue(10);
        Producer p = new Producer();
        Consumer[] c = new Consumer[5];
        for (int i=0;i<5;i++) {
            c[i] = new Consumer(i+1);
        }
        try {
            p.join();
            for (int i=0;i<5;i++) {
                c[i].join();
            }
        } catch (Exception e) {
            System.err.println("Error 0: "+e);
        }
    }
}