Scribd
Upload
21 views15 pages

ICLP c2 Java2

Uploaded by

Traian Șerbănuță
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
21 views15 pages

ICLP c2 Java2

Uploaded by

Traian Șerbănuță
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

Implementarea Concurent, ei în limbaje de

programare
JAVA 2

Traian Florin S, erbănut, ă

FMI @ UNIBUC

1
The Producer-Consumer Problem

2
The Producer-Consumer Problem
The Producer-Consumer Problem

--------
----------> | BUFFER | --------->
producer -------- consumer
Problem description
Two threads communicate through a buffer (shared memory):
• The Producer “produces” data and puts it in a buffer
• The Consumer takes the data from the buffer and “consumes”
it

Coordination problems
• Producer and consumer should not access the buffer
simultaneously
• Producer must wait if the buffer is full
• Consumer must wait if the buffer is empty
• Producer and Consumer should let each-other know when 3
Buffer interface

public interface DropBox<T> {


/**
* Puts a message in the dropbox
* @ return whether the operation succeeded ( dropbox open)
*/
boolean put(T message) throws InterruptedException;
/**
* Takes a message from the dropbox
* @ return an optional message, if dropbox open
*/
Optional<T> take() throws InterruptedException;
/**
* Closes the dropbox, making subsequent calls invalid
*/
void close();
}

4
Implementing the producer

public class ProducerThread<T> implements Runnable {


private final DropBox<T> box;
private Collection<T> items;

public ProducerThread(DropBox box, Collection<T> items)


{ this.box = box; this.items = items; }

@Override public void run() {


Random rnd = new Random();
try {
for (T item : items)
{ box.put(item); Thread.sleep(rnd.nextInt(2000)); }
} catch (InterruptedException e)
System.err.println("Got interrupted!");
}
}

5
Implementing the consumer

public class ConsumerThread<T> implements Runnable {


private final DropBox<T> box;
private final Consumer<T> handle;

public ConsumerThread(DropBox<T> box, Consumer<T> handle)


{ this.box = box; this.handle = handle; }

@Override public void run() {


try {
Optional<T> message = box.take();
while (message.isPresent())
{handle.accept(message.get()); message = box.take();}
} catch (InterruptedException e)
System.err.println("Got interrupted!");
}
}

6
Synchonization control through the Object class

void wait(), void wait(long milisecunde) the thread enters


the WAITING state, waiting to receive a notifyAll
or a notify signal for the object’s intrinsic lock

void notifyAll() wakes up all threads waiting on this object’s


intrinsic lock

void notify() wakes up a single thread waiting on this object’s


intrinsic lock

• the thread is randomly chosen

7
object.wait()

• Must be called from within a block synchronized on object


• Frees object’s intrinsic lock
• Waits until notified by notify/notifyAll
• When notified, it attempts to reaquire object’s intrinsic lock
• Throws an InterruptedException if the thread is
interrrupded while in WAITING state

synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}

Important
Always enclose obj.wait() in a loop due to spurious wakeup

8
Implementing a buffer of size 1 (close s, i put)

public class Cell<T> implements DropBox<T> {


private T cell = null;
private boolean open = true;

@Override public synchronized void close()


{ open = false; notifyAll(); }

@Override public synchronized boolean put(T message)


throws InterruptedException {
while (open && cell != null) wait();
if (!open) return false;
cell = message;
notifyAll();
return true;
}

9
Implementing a buffer of size 1 (take)

@Override public synchronized Optional<T> take()


throws InterruptedException {
while (open && cell == null) wait();
if (open) notifyAll();
T message = cell;
cell = null;
return Optional.ofNullable(message);
}
}

Note
• Using synchronized methods to prevent simultaneous access
• Using wait guards to block when buffer is full/empty
• Thread is suspended until receiving notify by partener thread

10
A possible main function for Producer-Consumer

public static void main(String [] args)


throws InterruptedException {
DropBox<String> box = new Cell<>();
ProducerThread<String> p1 = new ProducerThread<>(box,
Arrays.asList("This", "is", "important"));
ProducerThread<String> p2 = new ProducerThread<>(box,
Arrays.asList("so", "incredibly", "much", "highly"));
ConsumerThread<String> c = new ConsumerThread<>(box,
message -> System.out.format("%s received %s%n",
Thread.currentThread().getName(), message));
Thread pt1 = new Thread(p1); Thread pt2 = new Thread(p2);
Thread ct1 = new Thread(c); Thread ct2 = new Thread(c);
pt1.start(); pt2.start(); ct1.start(); ct2.start();
pt1.join(); pt2.join(); box.close();
ct1.join();ct2.join(); System.out.println("DONE");
}

11
Possible execution trace

Thread-2 received This


Thread-3 received so
Thread-2 received is
Thread-3 received incredibly
Thread-2 received important
Thread-3 received much
Thread-2 received highly
DONE

12
BlockingQueue

void put(E e) throws InterruptedException{.java} adds


element to the queue; waits if queue is full (blocking)

boolean offer(E e){.java} adds element to the queue if possible;


returns true upon success (non-blocking)

E take() throws InterruptedException{.java} retrieves an


element from the queue; waits if queue is empty
(blocking)

E poll(){.java} retrieves an element from the queue, if available;


returns true upon success (non-blocking)

13
Classes implementing BlockingQueue

ArrayBlockingQueue Bounded queue (the standard


producer-consumer buffer)

DelayQueue Queue of events with delays (expiration times).


Element can only be taken when its delay has expired.

LinkedTransferQueue Unbounded queue; producer may choose to


wait for element to be consumed

SynchronousQueue a zero-sized queue (synchronous


communication channel)

PriorityBlockingQueue Unbounded priority queue (heap)

14

You might also like