/**

* Original code by Silberschatz, Galvin, and Gagne

* from Operating System Concepts with Java, 7th Edition

* Modified by William Albritton

*

* This creates the buffer and the producer and consumer threads.

*

*/

import java.util.Date;

// import java.util.concurrent.Semaphore;



class Semaphore {

private int sem;

//

public synchronized void swait() {

while ( sem <= 0) {

try {

wait (500);

} catch (Exception e) { System.exit(0);};

}// II end while

sem--; // II decrease value of sem

}// end swait

//

public synchronized void signal() {

sem++;

notify();

} // end signal

//

// constructor

public Semaphore ( int intval) {

sem = intval; // initialize attribute sem

} // end class Semaphore

}

public class Solution{

public static void main(String args[]) {

//instantiate (create) buffer shared by Producer & Consumer

Buffer sharedBuffer = new BoundedBuffer();

// create the producer and consumer threads

Thread producerThread = new Thread(new Producer(sharedBuffer));

Thread consumerThread = new Thread(new Consumer(sharedBuffer));

//start() method allocates memory for a new thread in the JVM,

//and calls the run() method

producerThread.start();

consumerThread.start();

}

}

//*****************************************************************

/**

* An interface for buffers

*

*/

interface Buffer{

/**

* insert an item into the Buffer.

* Note this may be either a blocking

* or non-blocking operation.

*/

public abstract void insert(Object item);

/**

* remove an item from the Buffer.

* Note this may be either a blocking

* or non-blocking operation.

*/

public abstract Object remove();

}

//******************************************************************

/**

* This program implements the bounded buffer using shared memory.

*/

class BoundedBuffer implements Buffer{

private static final int BUFFER_SIZE = 500; //max size of buffer array

private int count; //number of items currently in the buffer

private int in; // points to the next free position in the buffer

private int out; // points to the first filled position in the buffer

private Object[] buffer; //array of Objects

private Semaphore mutex; //provides limited access to the buffer (mutual exclusion)

private Semaphore empty; //keep track of the number of empty elements in the array

private Semaphore full; //keep track of the number of filled elements in the array

public BoundedBuffer(){

// buffer is initially empty

count = 0;

in = 0;

out = 0;

buffer = new Object[BUFFER_SIZE];

mutex = new Semaphore(1); //1 for mutual exclusion

empty = new Semaphore(BUFFER_SIZE); //array begins with all empty elements

full = new Semaphore(0); //array begins with no elements

}

// producer calls this method

public void insert(Object item) {

empty.swait(); //keep track of number of empty elements (value--)

//This provides synchronization for the producer,

//because this makes the producer stop running when buffer is full

mutex.swait(); //mutual exclusion

// add an item to the buffer

++count;

buffer[in] = item;

//modulus (%) is the remainder of a division

//for example, 0%3=0, 1%3=1, 2%3=2, 3%3=0, 4%3=1, 5%3=2

in = (in + 1) % BUFFER_SIZE;

//buffer information feedback

if (count == BUFFER_SIZE){

System.out.println("BUFFER FULL "

+ "Producer inserted \"" + item

+ "\" count=" + count + ", "

+ "in=" + in + ", out=" + out);

}

else{

System.out.println("Producer inserted \"" + item

+ "\" count=" + count + ", "

+ "in=" + in + ", out=" + out);

}

mutex.signal(); //mutual exclusion

full.signal(); //keep track of number of elements (value++)

//If buffer was empty, then this wakes up the Consumer

}

// consumer calls this method

public Object remove() {

Object item=null;

/*

while (count == 0){

//if nothing in the buffer, then do nothing

//the buffer array cannot be used (because empty)

}

*/

full.swait(); //keep track of number of elements (value--)

//This provides synchronization for consumer,

//because this makes the Consumer stop running when buffer is empty

mutex.swait(); //mutual exclusion

// remove an item from the buffer

--count;

item = buffer[out];

//modulus (%) is the remainder of a division

//for example, 0%3=0, 1%3=1, 2%3=2, 3%3=0, 4%3=1, 5%3=2

out = (out + 1) % BUFFER_SIZE;

//buffer information feedback

if (count == 0){

System.out.println("BUFFER EMPTY "

+ "Consumer removed \"" + item

+ "\" count=" + count + ", "

+ "in=" + in + ", out=" + out);

}

else{

System.out.println("Consumer removed \"" + item

+ "\" count=" + count + ", "

+ "in=" + in + ", out=" + out);

}

mutex.signal(); //mutual exclusion

empty.signal(); //keep track of number of empty elements (value++)

//if buffer was full, then this wakes up the Producer

return item;

}

}

//***************************************************************

/**

* This is the producer thread for the bounded buffer problem.

*/

class Producer extends Thread{

private Buffer buffer;

public Producer(Buffer b) {

buffer = b;

}

public void run(){

Date message;

while (true) {

System.out.println("Producer napping");

SleepUtilities.nap();

// produce an item & enter it into the buffer

message = new Date();

System.out.println("Producer produced \"" + message + "\"");

buffer.insert(message);

}

}

}

//*******************************************************

/**

* This is the consumer thread for the bounded buffer problem.

*/

class Consumer extends Thread{

private Buffer buffer;

public Consumer(Buffer b) {

buffer = b;

}

public void run(){

Date message = null;

while (true){

System.out.println("Consumer napping");

SleepUtilities.nap();

// consume an item from the buffer

System.out.println("Consumer wants to consume");

message = (Date)buffer.remove();

System.out.println("Consumer consumed \"" + message + "\"");

}

}

}

//*********************************************************

/**

* Utilities for causing a thread to sleep.

* Note, we should be handling interrupted exceptions

* but choose not to do so for code clarity.

*

*/

class SleepUtilities{

private static final int NAP_TIME = 5; //max nap time in seconds

/**

* Nap between zero and NAP_TIME seconds.

*/

public static void nap() {

nap(NAP_TIME);

}

/**

* Nap between zero and duration seconds.

*/

public static void nap(int duration) {

int sleeptime = (int) (NAP_TIME * Math.random() );

System.out.println("Nap for " + sleeptime + " seconds");

//Causes the currently executing thread to sleep (cease execution)

//for the specified number of milliseconds,

//subject to the precision and accuracy of system timers and schedulers.

try { Thread.sleep(sleeptime*1000); }

catch (InterruptedException e) {

//method sleep() throws InterruptedException - if any thread has interrupted the current thread.

System.out.println("ERROR in nap(): " + e);

}

}

}

/*output:-

"Thu Oct 19 04:11:05 IST 2017"

Producer inserted "Thu Oct 19 04:11:05 IST 2017" count=11, in=104, out=93

Producer napping

Nap for 3 seconds

Producer produced "Thu Oct 19 04:11:08 IST 2017"

Producer inserted "Thu Oct 19 04:11:08 IST 2017" count=12, in=105, out=93

Producer napping

Nap for 4 seconds

Consumer wants to consume

Consumer removed "Thu Oct 19 04:10:45 IST 2017" count=11, in=105, out=94

Consumer consumed "Thu Oct 19 04:10:45 IST 2017"

Consumer napping

Nap for 0 seconds

Consumer wants to consume

Consumer removed "Thu Oct 19 04:10:46 IST 2017" count=10, in=105, out=95

Consumer consumed "Thu Oct 19 04:10:46 IST 2017"

Consumer napping

Nap for 1 seconds

Consumer wants to consume

Consumer removed "Thu Oct 19 04:10:46 IST 2017" count=9, in=105, out=96

Consumer consumed "Thu Oct 19 04:10:46 IST 2017"

Consumer napping

Nap for 3 seconds

Producer produced "Thu Oct 19 04:11:12 IST 2017"

Producer inserted "Thu Oct 19 04:11:12 IST 2017" count=10, in=106, out=96

Producer napping

Nap for 4 seconds

Consumer wants to consume

Consumer removed "Thu Oct 19 04:10:46 IST 2017" count=9, in=106, out=97

Consumer consumed "Thu Oct 19 04:10:46 IST 2017"

Consumer napping

Nap for 2 seconds

Consumer wants to consume

Consumer removed "Thu Oct 19 04:10:47 IST 2017" count=8, in=106, out=98

Consumer consumed "Thu Oct 19 04:10:47 IST 2017"

Consumer napping

Nap for 2 seconds

Producer produced "Thu Oct 19 04:11:16 IST 2017"   .... continue.

until you terminate the program

*/