Producer/Consumer CSCI 201 Principles of Software Development

Transcription

1 Producer/Consumer CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D.

2 Outline Producer/Consumer Program USC CSCI 201L

3 Producer/Consumer Overview The producer/consumer problem is a famous problem for concurrent programming Assume you have a soda machine with a number of delivery people (producers) and a number of people wanting to buy sodas (consumers) Each producer can insert as many sodas as he has, up to the capacity of the soda machine Each consumer can purchase as many sodas as he wants, up to the current number in the soda machine If there are not enough sodas for a consumer to buy, he needs to wait until there are If there is not enough room for the producer to insert the number of sodas he has, he needs to wait until there is This problem can produce a situation called deadlock Download the ProducerConsumerWithMonitors.java from the course web site and execute it What line(s) of code produce the potential deadlock? USC CSCI 201L 3/10

4 Producer/Consumer Example Put this one soda in the soda machine! Is there a soda in Yay! Yes! Thanks No? the I m machine Thanks There s I guess thirsty! for the I ll for a for soda soda! have the now! soda! to me wait to buy? Hey, Is No? there I there s need space to space in now! the wait soda for I ll there put machine the to soda for be space! a soda? in. USC CSCI 201L 4/10

5 Producer/Consumer Example with Monitors 1 import java.util.linkedlist; 2 import java.util.concurrent.executorservice; 3 import java.util.concurrent.executors; 4 5 public class ProducerConsumerWithMonitors { 6 private static Buffer buffer = new Buffer(); 7 8 public static void main(string [] args) { 9 ExecutorService executor = Executors.newFixedThreadPool(2); 10 executor.execute(new ProducerTask()); 11 executor.execute(new ConsumerTask()); 12 executor.shutdown(); 13 } private static class ProducerTask implements Runnable { 16 public void run() { 17 try { 18 int i = 1; 19 while (true) { 20 System.out.println("Producer writes: " + i); 21 buffer.write(i++); 22 Thread.sleep((int)(Math.random() * 1000)); 23 } 24 } catch (InterruptedException ie) { 25 System.out.println("Producer IE: " + ie.getmessage()); 26 } 27 } 28 } private static class ConsumerTask implements Runnable { 31 public void run() { 32 try { 33 while (true) { 34 System.out.println("\t\tConsumer reads: " + buffer.read()); 35 Thread.sleep((int)(Math.random() * 1000)); 36 } 37 } catch (InterruptedException ie) { 38 System.out.println("Consumer IE: " + ie.getmessage()); 39 } 40 } 41 } 42 private static class Buffer { 43 private static final int CAPACITY = 1; 44 private LinkedList<Integer> queue = new LinkedList<Integer>(); 45 private static Object notempty = new Object(); 46 private static Object notfull = new Object(); 47 public void write(int value) { 48 synchronized(notfull) { 49 synchronized(notempty) { 50 try { 51 while (queue.size() == CAPACITY) { 52 System.out.println("Wait for notfull condition " + value); 53 notfull.wait(); 54 } 55 queue.offer(value); 56 notempty.notify(); 57 } catch (InterruptedException ie) { 58 System.out.println("Buffer.write IE: " + ie.getmessage()); 59 } 60 } 61 } 62 } 63 public int read() { 64 int value = 0; 65 synchronized(notfull) { 66 synchronized(notempty) { 67 try { 68 while (queue.isempty()) { 69 System.out.println("\t\tWait for notempty condition"); 70 notempty.wait(); 71 } 72 value = queue.remove(); 73 notfull.notify(); 74 } catch (InterruptedException ie) { 75 System.out.println("Buffer.read IE: " + ie.getmessage()); 76 } 77 } 78 } 79 return value; 80 } 81 } // ends class Buffer 82 } // ends class ProducerConsumerWithMonitors USC CSCI 201L 5/10

6 Producer/Consumer Example with Monitors Even if we reduce this to only having one monitor, there is a possible race condition. Assume the following execution The Consumer checks to see if the queue is empty (line 64) and enters the loop. The Consumer is switched out of the CPU in the middle of line 66, specifically after giving up the lock but before moving to the waiting state. The Producer executes and adds a soda into the queue on line 53, then notifies any thread waiting on the sodamachine (which is no one currently). The Consumer then runs again and gets moved into the waiting state, waiting on the sodamachine on line 66. The Producer then runs again and finds that the queue is at capacity (line 49), so it waits (line 51). We now have a deadlock state. 42 private static class Buffer { 43 private static final int CAPACITY = 1; 44 private LinkedList<Integer> queue = new LinkedList<Integer>(); 45 private static Object sodamachine = new Object(); 46 public void write(int value) { 47 synchronized(sodamachine) { 48 try { 49 while (queue.size() == CAPACITY) { 50 System.out.println("Wait for notfull condition " + value); 51 sodamachine.wait(); 52 } 53 queue.offer(value); 54 sodamachine.notify(); 55 } catch (InterruptedException ie) { 56 System.out.println("Buffer.write IE: " + ie.getmessage()); 57 } 58 } 59 } 60 public int read() { 61 int value = 0; 62 synchronized(sodamachine) { 63 try { 64 while (queue.isempty()) { 65 System.out.println("\t\tWait for notempty condition"); 66 sodamachine.wait(); 67 } 68 value = queue.remove(); 69 sodamachine.notify(); 70 } catch (InterruptedException ie) { 71 System.out.println("Buffer.read IE: " + ie.getmessage()); 72 } 73 } 74 return value; 75 } 76 } // ends class Buffer 77 } // ends class ProducerConsumerWithMonitors USC CSCI 201L 6/10

7 Producer/Consumer Example with Locks/Conditions 1 import java.util.linkedlist; 2 import java.util.concurrent.executorservice; 3 import java.util.concurrent.executors; 4 import java.util.concurrent.locks.condition; 5 import java.util.concurrent.locks.lock; 6 import java.util.concurrent.locks.reentrantlock; 7 8 public class ProducerConsumerWithLocks { 9 private static Buffer buffer = new Buffer(); 10 public static void main(string [] args) { 11 ExecutorService executor = Executors.newFixedThreadPool(2); 12 executor.execute(new ProducerTask()); 13 executor.execute(new ConsumerTask()); 14 executor.shutdown(); 15 } 16 private static class ProducerTask implements Runnable { 17 public void run() { 18 try { 19 int i = 1; 20 while (true) { 21 System.out.println("Producer tries to write: " + i); 22 buffer.write(i++); 23 Thread.sleep((int)(Math.random() * 1000)); 24 } 25 } catch (InterruptedException ie) { 26 System.out.println("Producer IE: " + ie.getmessage()); 27 } 28 } 29 } 30 private static class ConsumerTask implements Runnable { 31 public void run() { 32 try { 33 while (true) { 34 System.out.println("\t\tConsumer reads: " + buffer.read()); 35 Thread.sleep((int)(Math.random() * 1000)); 36 } 37 } catch (InterruptedException ie) { 38 System.out.println("Consumer IE: " + ie.getmessage()); 39 } 40 } 41 } 42 private static class Buffer { 43 private static final int CAPACITY = 1; 44 private LinkedList<Integer> queue = new LinkedList<Integer>(); 45 private static Lock lock = new ReentrantLock(); 46 private static Condition notempty = lock.newcondition(); 47 private static Condition notfull = lock.newcondition(); 48 public void write(int value) { 49 lock.lock(); 50 try { 51 while (queue.size() == CAPACITY) { 52 System.out.println("Wait for notfull condition " + value); 53 notfull.await(); 54 } 55 queue.offer(value); 56 notempty.signal(); 57 } catch (InterruptedException ie) { 58 System.out.println("Buffer.write IE: " + ie.getmessage()); 59 } finally { 60 lock.unlock(); 61 } 62 } 63 public int read() { 64 int value = 0; 65 lock.lock(); 66 try { 67 while (queue.isempty()) { 68 System.out.println("\t\tWait for notempty condition"); 69 notempty.await(); 71 } 70 value = queue.remove(); 71 notfull.signal(); 72 } catch (InterruptedException ie) { 73 System.out.println("Buffer.read IE: " + ie.getmessage()); 74 } finally { 75 lock.unlock(); 76 return value; 77 } 78 } 79 } // ends class Buffer 80 } // ends class ProducerConsumerWithLocks USC CSCI 201L 7/10

8 Producer/Consumer Output with Locks/Conditions USC CSCI 201L 8/10

9 Outline Producer/Consumer Program USC CSCI 201L

10 Program Modify the Producer/Consumer program with locks so that a Producer will never write two lines in a row. Also provide an output line when a Producer or Consumer is notified or signaled. USC CSCI 201L 10/10