CONCURRENT API AND PARALLEL PROGRAMMING

Transcription

1 MODULE 11 CONCURRENT API AND PARALLEL PROGRAMMING Module 11.A THREAD MODEL: RUNNABLE, CALLABLE, FUTURE, FUTURETASK

2 Threads > What are threads? Threads are a virtual CPU. > The three parts of at thread are: CPU Code Data Creating the Thread

3 Creating the Thread > Multithreaded programming has these characteristics: Multiple threads are from one Runnable instance. Threads share the same data and code. > For example: Thread t1 = new Thread(r); Thread t2 = new Thread(r); > Use the start method. Starting the Thread > Place the thread in a runnable state.

4 Thread Scheduling Daemon Threads > You can turn a thread into a daemon thread by calling t.setdaemon(true); > This method must be called before the thread is started. > A daemon is simply a thread that has no other role in life than to serve others. > When only daemon threads remain, the virtual machine exits. > A daemon thread should never access a persistent resource such as a file or database since it can terminate at any time, even in the middle of an operation.

5 Thread Scheduling Example Terminating a Thread

6 Terminating a Thread > A thread terminates when its run method returns, by executing a return statement, after executing the last statement in the method body, or if an exception occurs that is not caught in the method. > In the initial release of Java, there also was a stop method that another thread could call to terminate a thread. > However, that method is now deprecated. Terminating a Thread > There is a way to force a thread to terminate. > However, the interrupt method can be used to request termination of a thread. > When the interrupt method is called on a thread, the interrupted status of the thread is set. > This is a boolean flag that is present in every thread. > Each thread should occasionally check whether it has been interrupted. while (!Thread.currentThread().isInterrupted()) { } do more work

7 Terminating a Thread > There is no language requirement that a thread that is interrupted should terminate. > Interrupting a thread simply grabs its attention. The interrupted thread can decide how to react to the interruption. > Some threads are so important that they should handle the exception and continue. > But quite commonly, a thread will simply want to interpret an interruption as a request for termination. > Test threads: isalive() > Access thread priority: getpriority() setpriority() Basic Control of Threads > Put threads on hold: Thread.sleep() // static method join() Thread.yield() // static method

8 The join Method Handlers for Uncaught Exceptions > The run method cannot throw any checked exceptions, but it can be terminated by an unchecked exception. In that case, the thread dies. > However, there is no catch clause to which the exception can be propagated. Instead, just before the thread dies, the exception is passed to a handler for uncaught exceptions. > You can install a handler into any thread with the setuncaughtexceptionhandler method. > You can also install a default handler for all threads with the static method setdefaultuncaughtexceptionhandler of the Thread class.

9 java.lang.thread > static void setdefaultuncaughtexceptionhandler( Thread.UncaughtExceptionHandler handler) > static Thread.UncaughtExceptionHandler getdefaultuncaughtexceptionhandler() sets or gets the default handler for uncaught exceptions. > void setuncaughtexceptionhandler( Thread.UncaughtExceptionHandler handler) > Thread.UncaughtExceptionHandler getuncaughtexceptionhandler() sets or gets the handler for uncaught exceptions. If no handler is installed, the thread group object is the handler. java.lang.thread.uncaughtexceptionhandler >void uncaughtexception(thread t, Throwable e) defined to log a custom report when a thread is terminated with an uncaught exception. > Parameters t The thread that was terminated due to an uncaught exception e The uncaught exception object

10 Thread t= new Thread(new Runnable() public void run() { } }); throw new IllegalArgumentException(); t.setuncaughtexceptionhandler( new Thread.UncaughtExceptionHandler() }); public void uncaughtexception(thread t, } Throwable e) { System.err.println(e.getMessage()); t.start(); Callables and Futures > A Runnable encapsulates a task that runs asynchronously; you can think of it as an asynchronous method with no parameters and no return value. > A Callable is similar to a Runnable, but it returns a value. > The Callable interface is a parameterized type, with a single method call. public interface Callable<V> { } V call() throws Exception;

11 Callables and Futures > A Future holds the result of an asynchronous computation. > Use a Future object so that you can start a computation, give the result to someone, and forget about it. > The owner of the Future object can obtain the result when it is ready: public interface Future<V> { V get() throws...; V get(long timeout, TimeUnit unit); void cancel(boolean mayinterrupt); boolean iscancelled(); boolean isdone(); } get() > A call to the first get method blocks until the computation is finished. > The second method throws a TimeoutException if the call timed out before the computation finished. > If the thread running the computation is interrupted, both methods throw an InterruptedException. > If the computation has already finished, then get returns immediately.

12 isdone() > The isdone method returns false if the computation is still in progress, true if it is finished. iscancelled() > You can cancel the computation with the cancel method. > If the computation has not yet started, it is canceled and will never start. > If the computation is currently in progress, then it is interrupted if the mayinterrupt parameter is true.

13 FutureTask > The FutureTask wrapper is a convenient mechanism for turning a Callable into both a Future and a Runnable, it implements both interfaces: Callable<Integer> mycomputation =...; FutureTask<Integer> task = new FutureTask<Integer>(myComputation); Thread t = new Thread(task); t.start();... Integer result = task.get(); Module 11.B THREAD SYNCHRONIZATION

14 Using the synchronizedkeyword The Object Lock Flag > Every object has a flag that is a type of lock flag. > The synchronized enables interaction with the lock flag.

15 The Object Lock Flag The Object Lock Flag

16 Releasing the Lock Flag >The lock flag is released in the following events: > Released when the thread passes the end of the synchronized code block > Released automatically when a break, return, or exception is thrown by the synchronized code block Synchronization

17 Thread Interaction wait and notify > Scenario: Consider yourself and a cab driver as two threads. > The problem: How do you determine when you are at your destination? > The solution: You notify the cab driver of your destination and relax. The driver drives and notifies you upon arrival at your destination. Thread Interaction >Thread interactions include: > The wait and notify methods > The pools: Wait pool Lock pool

18 Thread State Diagram With wait and notify Monitor Model for Synchronization > Leave shared data in a consistent state. > Ensure programs cannot deadlock. > Do not put threads expecting different notifications in the same wait pool.

19 The Producer Class The Producer Class

20 The Consumer Class The Consumer Class

21 The SyncStack Class This is a sketch of the SyncStack class: The pop Method

22 The push Method The SyncTest Class

23 Concurrency Library > The concurrency library has convenient, high-level utilities for developing high-performence, multi-threaded programs. > The concurrency library frees you from having to develop those utilities by hand (based upon low-level language concurrency primitives) Advantages > Reduced programming effort: It is easier to use a standard class than re-inventing the wheel > Increased performance: The implementations have been developed and tested by concurrency and performance experts, and therefore, they are faster and more scalable than typical implementations > Increased reliability: The low-level concurrency primitives (such as synchronized, wait(), and notify()) are difficult to use correctly and errors are not easy to detect or debug. On the other hand, the concurrency utilities are standardized and extensively tested against deadlock, starvation, or race conditions.

24 Advantages > Improved maintainability: Applications that are based on standardized packages are easier to maintain > Increased productivity: Programmers are likely to already understand the standard library classes, so there is no need to learn new APIs Libraries > java.util.concurrent Classes commonly used in concurrent programming, for example, thread pools > java.util.concurrent.atomic Classes that support atomic operations on single variables, for example, atomic counters > java.util.concurrent.locks Classes for locking and waiting for conditions

25 Lock Objects > Starting with Java SE 5.0, there are two mechanisms for protecting a code block from concurrent access. 1. The Java language provides a synchronized keyword for this purpose 2. Java SE 5.0 introduced the ReentrantLock class. mylock.lock(); // a ReentrantLock object try { critical section } finally { mylock.unlock(); } java.util.concurrent.locks.lock > void lock() acquires this lock; blocks if the lock is currently owned by another thread. > void unlock() releases this lock.

26 java.util.concurrent.locks.reentrantlock > ReentrantLock() constructs a reentrant lock that can be used to protect a critical section. > ReentrantLock(boolean fair) constructs a lock with the given fairness policy. A fair lock favors the thread that has been waiting for the longest time. However, this fairness guarantee can be a significant drag on performance. Therefore, by default, locks are not required to be fair. ReentrantReadWriteLock > ReentrantReadWriteLock Provides better performance in cases where there are many readers but few writers. readlock() writelock() getreadholdcount() getwriteholdcount()

27 Condition Objects > A thread enters a critical section, only to discover that it can t proceed until a condition is fulfilled. Condition condition= lock.newcondition(); > You use a condition object to manage threads that have acquired a lock but cannot do useful work. while (!(ok to proceed)) condition.await(); > Some other thread calls signalall eventually > Note that the call to signalall does not immediately activate a waiting thread. It only unblocks the waiting threads so that they can compete for entry into the object after the current thread has exited the synchronized method. Module 11.C EXECUTORS

28 Executors > Constructing a new thread is somewhat expensive because it involves interaction with the operating system. > If your program creates a large number of short-lived threads, then it should instead use a thread pool. > A thread pool contains a number of idle threads that are ready to run. > You give a Runnable to the pool, and one of the threads calls the run method. > When the run method exits, the thread doesn't die but stays around to serve the next request. Executors > The Executors class has a number of static factory methods for constructing thread pools Method newcachedthreadpool newfixedthreadpool newsinglethreadexecutor newscheduledthreadpool newsinglethreadscheduledexecutor Description New threads are created as needed; idle threads are kept for 60 seconds. The pool contains a fixed set of threads; idle threads are kept indefinitely. A "pool" with a single thread that executes the submitted tasks sequentially. A fixed-thread pool for scheduled execution. A single-thread "pool" for scheduled execution.

29 Thread Pools > You can submit a Runnable or Callable to an ExecutorService with one of the following methods: Future<?> submit(runnable task) Future<T> submit(runnable task, T result) Future<T> submit(callable<t> task) > The pool will run the submitted task at its earliest convenience. > When you call submit, you get back a Future object that you can use to query the state of the task. Thread Pools 1. Call the static newcachedthreadpool or newfixedthreadpool method of the Executors class. 2. Call submit to submit Runnable or Callable objects. 3. If you want to be able to cancel a task or if you submit Callable objects, hang on to the returned Future objects. 4. Call shutdown when you no longer want to submit any tasks.

30 Module 11.D SYNCHRONIZERS java.util.concurrent.atomic > The classes in this package allow multiple operations to be treated atomically. > As an example, a volatile integer cannot be used with the ++ operator because this operator contains multiple instructions. > The AtomicInteger class has a method that allows the integer it holds to be incremented atomically without using synchronization. > Atomic classes, however, can be used for more complex tasks, such as building code that requires no synchronization

31 Example import java.util.concurrent.atomic.*; public class SequenceGenerator { private AtomicLong number = new AtomicLong(0); public long next() { return number.getandincrement(); } } java.util.concurrent.atomic > Instances of classes AtomicBoolean, AtomicInteger, AtomicLong, and AtomicReference each provide access and updates to a single variable of the corresponding type. > Atomic classes don t inherit from the similarly named classes, so AtomicBoolean can t be used in place of a Boolean, and AtomicInteger isn t an Integer

32 Synchronizers > The java.util.concurrent package contains several classes that help manage a set of collaborating threads > These mechanisms have "canned functionality" for common rendezvous patterns between threads. > If you have a set of collaborating threads that follows one of these behavior patterns, you should simply reuse the appropriate library class instead of trying to come up with a handcrafted collection of locks. Synchronizers Class What It Does When To Use CyclicBarrier CountDownLatch Exchanger Allows a set of threads to wait until a predefined count of them has reached a common barrier, and then optionally executes a barrier action. Allows a set of threads to wait until a count has been decremented to 0. Allows two threads to exchange objects when both are ready for the exchange. When a number of threads need to complete before their results can be used. When one or more threads need to wait until a specified number of results are available. When two threads work on two instances of the same data structure, one by filling an instance and the other by emptying the other.

33 Synchronizers Class What It Does When To Use SynchronousQueue Allows a thread to hand off an object to another thread. To send an object from one thread to another when both are ready, without explicit synchronization. Semaphore Allows a set of threads to wait until permits are available for proceeding. To restrict the total number of threads that can access a resource. If permit count is one, use to block threads until another thread gives permission. Barriers > The CyclicBarrier class implements a rendezvous called a barrier. > Consider a number of threads that are working on parts of a computation. > When all parts are ready, the results need to be combined. > When a thread is done with its part, we let it run against the barrier. > Once all threads have reached the barrier, the barrier gives way and the threads can proceed. > Here are the details.

34 Barriers > First, construct a barrier, giving the number of participating threads: CyclicBarrier barrier = new CyclicBarrier(nthreads); > Each thread does some work and calls await on the barrier upon completion: public void run() { } dowork(); barrier.await();... > The await method takes an optional timeout parameter barrier.await(100, TimeUnit.MILLISECONDS); Countdown Latches > A CountDownLatch lets a set of threads wait until a count has reached zero. > It differs from a barrier in these respects: Not all threads need to wait for the latch until it can be opened. The latch can be counted down by external events. The countdown latch is one-time only. Once the count has reached 0, you cannot reuse it. A useful special case is a latch with a count of 1. This implements a one-time gate. Threads are held at the gate until another thread sets the count to 0.

35 java.util.concurrent.countdownlatch > CountdownLatch(int count) constructs a countdown latch with the given count. > void await() waits for this latch to count down to 0. > boolean await(long time,timeunit unit) waits for this latch to count down to 0 or for the timeout to elapse. Returns true if the count is 0, false if the timeout elapsed. > public void countdown() counts down the counter of this latch. Exchangers > An Exchanger is used when two threads are working on two instances of the same data buffer. > Typically, one thread fills the buffer, and the other consumes its contents. When both are done, they exchange their buffers.

36 java.util.concurrent.exchanger<v> V exchange(v item) V exchange(v item, long time, TimeUnit unit) blocks until another thread calls this method, and then exchanges the item with the other thread and returns the other thread's item. The second method throws a TimeoutException after the timeout has elapsed. Exchanger - Example >Consumer Thread try { while (currentbuffer!= null) { takefrombuffer(currentbuffer); if (currentbuffer.empty()) currentbuffer= exchanger.exchange(currentbuffer); } } catch (InterruptedException ex) { //... handle... }

37 Exchanger - Example >Producer Thread try { while (currentbuffer!= null) { addtobuffer(currentbuffer); if (currentbuffer.full()) currentbuffer=exchanger.exchange(currentbuffer); } } catch (InterruptedException ex) { //... handle... } Semaphores > Conceptually, a semaphore manages a number of permits. > To proceed past the semaphore, a thread requests a permit by calling acquire. > Only a fixed number of permits are available, limiting the number of threads that are allowed to pass. > Other threads may issue permits by calling release. > There are no actual permit objects. > The semaphore simply keeps a count.

38 Semaphores > Moreover, a permit doesn't have to be released by the thread that acquires it. > In fact, any thread can issue any number of permits. > If it issues more than the maximum available, the semaphore is simply set to the maximum count. This generality makes semaphores both very flexible and potentially confusing. > Semaphores were invented by Edsger Dijkstra in 1968, for use as a synchronization primitive. > Dijkstra showed that semaphores can be efficiently implemented and they are powerful enough to solve many common thread synchronization problems. java.util.concurrent.semaphore > Semaphore(int permits) > Semaphore(int permits, boolean fair) construct a semaphore with the given maximum number of permits. If fair is true, the queue favors the longestwaiting threads. > void acquire() > void acquire(int permits) waits to acquire a permit. > boolean tryacquire() tries to acquire a permit; returns false if none is available.

39 java.util.concurrent.semaphore > boolean tryacquire(long time,timeunit unit) tries to acquire a permit within the given time; returns false if none is available. > void release() releases a permit. Quiz #1 > In order to ensure that a service does not start until other services on which it depends have started, which Synchronizer is best suited for this purpose? a) CyclicBarrier b) CountDownLatch c) Exchanger d) Semaphore

40 Quiz #2 > In order to implement database connection pool, which Synchronizer is best suited for this purpose? a) CyclicBarrier b) CountDownLatch c) Exchanger d) Semaphore Quiz #3 > Multiple threads are downloading files, and you want to keep track of the total number of bytes that have been downloaded. Which of the followings is best suited for this purpose? a) Executor b) CyclicBarrier c) AtomicInteger d) Semaphore e) LinkedBlockingQueue

41 Quiz #4 > A thread is computing a value; other threads may need/request that value and if they need/request it before it is computed those threads should block until the value is ready. Which of the followings is best suited for this purpose? a) Lock b) Future c) AtomicInteger d) Semaphore e) AtomicBoolean Quiz #5 > You are going to create 8 threads for testing purposes, and you don t want the first thread that is started to begin executing some test code before the other threads have been started. Instead, you want to ensure that all threads have been started and that control has entered their run methods before any of them execute the test code. Which Synchronizer is best suited for this purpose? a) CyclicBarrier b) CountDownLatch c) Exchanger d) Semaphore

42 Quiz #6 > You want to allow no more than 4 active file downloads at a time. If one download is paused, that should allow another download to become active. If the user resumes a paused download, that download has to wait to actually resume until only 3 are currently active so as to not exceed the limit of 4 active downloads. Which Synchronizer is best suited for this purpose? a) CyclicBarrier b) CountDownLatch c) Exchanger d) Semaphore Quiz #7 > You have several threads, each updating the position of a character in a 3D world. You don t want a thread to start processing the next frame until all other threads have finished processing the previous frame. Which Synchronizer is best suited for this purpose? a) CyclicBarrier b) CountDownLatch c) Exchanger d) Semaphore