Lecture 7: Enhanced Concurrency in Java

Lecture 7: Enhanced Concurrency in Java • java.util.concurrent: – Semaphore class – Interface Lock/ Class Condition – Bounded Buffers Implementation – Bank Account Implementation – Interface Executor – Futures/Callables

CA463D Lecture Notes (Martin Crane 2014)

1

Recent Developments in java.util.concurrent • Up to now, have focused on the low-level APIs that have been part of the Java platform from the very beginning. • These APIs are adequate for basic tasks, but need higherlevel constructs for more advanced tasks (esp for massively parallel applications exploiting multi-core systems). • In this lecture we'll examine some high-level concurrency features introduced in more recent Java releases. • Most of these features are implemented in the new java.util.concurrent packages. • There are also new concurrent data structures in the Java Collections Framework. CA463D Lecture Notes (Martin Crane 2014)

2

Features in Brief • Semaphore objects are similar to what we have come up against already; acquire() & release() take the place of P , V (resp) • Lock objects support locking idioms that simplify many concurrent applications (don’t confuse with their implicit cousins seen above!) • Executors define a high-level API for launching, managing threads. • Executor implementations provide thread pool management suitable for large-scale applications. • Concurrent Collections support concurrent management of large collections of data in HashTables, different kinds of Queues etc. • Future objects are enhanced to have their status queried and return values when used in connection with asynchronous threads. • Atomic variables (eg AtomicInteger) support atomic operations on single variables have features that minimize synchronization and help avoid memory consistency errors. CA463D Lecture Notes (Martin Crane 2014)

3

Semaphore Objects • Often developers need to throttle the number of open requests (threads/actions) for a particular resource. • Sometimes, throttling can improve the throughput of a system by reducing the amount of contention against that particular resource. • Alternatively it might be a question of starvation prevention (cf room example of Dining Philosophers above) • Can write the throttling code by hand, it's easier to use semaphore class, which takes care of it for you. CA463D Lecture Notes (Martin Crane 2014)

4

Semaphore Example //SemApp: code to demonstrate semaphore class © Ted Neward import java.util.*;import java.util.concurrent.*; public class SemApp { public static void main( String[] args ) { Runnable limitedcall = new Runnable final Random rand = new Random(); final Semaphore available = new Semaphore(3); int count = 0; public void run() { int time = rand.nextInt(15); int num = count++; try { available.acquire(); System.out.println("Executing “ + run action for “ + time + “ secs.. #" + num); Thread.sleep(time * 1000); System.out.println("Done with # “ available.release(); } catch (InterruptedException intEx) intEx.printStackTrace(); } } }; for (int i=0; i