Multithreading

1. Multithreading Chapter 23

2. What You Will Learn • Thread States • Thread Synchronization • Producers and consumers

3. Introduction • Consider ability of human body to multitask • Breathing, heartbeat, chew gum, walk … • In many situations we need a computer to multitask • Concurrency normally available in OS primitives • Java provides built-in multithreading • Multithreading improves the performance of some programs

4. Thread States: Life Cycle of a Thread View diagram, Figure 23.1 • new state • New thread begins its life cycle in the new state • Remains in this state until program starts the thread, placing it in the runnable state • runnable state • A thread in this state is executing its task • waiting state • A thread transitions to this state to wait for another thread to perform a task

5. Thread States: Life Cycle of a Thread View diagram, Figure 23.1 • timed waiting state • A thread enters this state to wait for another thread or for an amount of time to elapse • A thread in this state returns to the runnable state when it is signaled by another thread or when the timed interval expires • terminated state • A runnable thread enters this state when it completes its task

6. Operating System View Of runnable State • ready state • Not waiting for another thread • Waiting for the operating system to assign the thread a processor

7. Operating System View Of runnable State • running state • Currently has a processor and is executing • Often executes for a small amount of processor time called a time slice or quantum before transitioning back to the ready state

8. Thread Priorities and Thread Scheduling • Java thread priority • Priority in range 1-10 • Timeslicing • Each thread assigned time on the processor (called a quantum) • Keeps highest priority threads running

9. Priorities and Scheduling Thread.MAX_PRIORITY

10. Creating and Executing Threads • Runnable interface • Preferred means of creating a multithreaded application • Declares method run • Executed by an object that implements the Executor interface • Executor interface • Declares method execute • Creates and manages a group of threads called a thread pool

11. Creating and Executing Threads • ExecutorService interface • Subinterface of Executor that declares other methods for managing the life cycle of an Executor • Can be created using static methods of class Executors • Method shutdown ends threads when tasks are completed

12. Creating and Executing Threads • Executors class • Method newFixedThreadPool creates a pool consisting of a fixed number of threads • Method newCachedThreadPool creates a pool that creates new threads as they are needed

13. Creating and Executing Threads • PrintTask class Figure 23.4 • RunnableTester, Figure 23.5 • Demonstrates • Constructing Thread objects • Using Thread methods start and sleep • Creates 3 equal priority threads • Each is put to sleep for random number of milliseconds • When awakened, it displays name, etc.

14. Producers and Consumers • Producer • Generatingoutput • Consumer • Receives and processesthe output

15. Synchronization • Problem • Sometimes the producer gets too far ahead of the consumer • The objects produced fill up the holding area (buffer) • The producer must wait for space to place objects • Sometimes the consumer gets ahead of the producer • There are no objects to be processed (empty buffer) • The consumer must wait for the producer

16. Thread Synchronization • Thread synchronization • Provided to the programmer with mutual exclusion • Exclusive access to a shared object • Implemented in Java using locks • Lock interface • lock method obtains the lock, enforcing mutual exclusion • unlock method releases the lock • Class ReentrantLock implements the Lock interface

17. Thread Synchronization • Condition variables • If a thread holding the lock cannot continue with its task until a condition is satisfied, the thread can wait on a condition variable • Create by calling Lock method newCondition • Represented by an object that implements the Condition interface

18. Thread Synchronization • Condition interface • Declares methods await, to make a thread wait, • signal, to wake up a waiting thread, and • signalAll, to wake up all waiting threads

19. Producer/Consumer Relationship without Synchronization • Buffer • Shared memory region • Producer thread • Generates data to add to buffer • Calls wait if consumer has not read previous message in buffer • Writes to empty buffer and calls notify for consumer • Consumer thread • Reads data from buffer • Calls wait if buffer empty • Synchronize threads to avoid corrupted data

20. Producer/Consumer Relationship without Synchronization • View source code which establishes • Buffer, Figure 23.6 • An interface which specifies get and set methods • Producer, Figure 23.7 • Subclass of Thread • Uses a shared Buffer object • Method run is overridden from Thread class • Uses Buffer.set() method • Consumer, Figure 23.8 • Also a subclass of Thread, also uses shared Buffer • Uses the Buffer.get() method

21. Producer/Consumer Relationship without Synchronization • View Figure 23.9 which implements the Buffer interface • Implements the get and set methods • This UnsynchronizedBuffer object is used in Figure 23.10 program • Buffer object declared, instantiated • Also Producer and Consumer objects • Both threads call method start()

22. Producer/Consumer Relationship without Synchronization • Example randomly called producer and consumer • You should note that in some cases the data was incorrect • Consumer reads values before producer generates • Consumer misses a value • Consumer reads same value multiple times • We need to deal with problem so data is not corrupted

23. Producer/Consumer Relationship with Synchronization • Solution is to synchronize the producer and consumer objects • Figure 23.11 implements a buffer and synchronizes • Consumer consumes only after produces a value • Producer produces a value only after consumer consumes previous value produced • Condition variable occupiedBufferCount determines whose turn it is • Program which uses this, Figure 23.12

24. Using Thread Methods • Create Waitclass • Has static methods • Provide capability to have another application pause for a certain amount of time • Note Example to act as a simple timer.

25. Circular Buffer • Features • Multiple memory cells • Produce item if one or more empty cells • Consume item if one or more filled cells • Caveats • Producer and consumers must be relatively same speed • Otherwise buffer fills up or stays empty • Synchronization still necessary • Seek to optimize buffer size • minimizes thread-wait time

26. Circular Buffer • Circular Buffer class Figure 23.13 • Lock for mutual exclusion • Condition variables to control writing and reading • Circular buffer; provides three spaces for data • Obtain the lock before writing data to the circular buffer • Wait until a buffer space is empty • Impose circularity of the buffer • Signal waiting thread when to read data from buffer • Release lock

27. Circular Buffer • Circular Buffer test, Figure 23.14 • Create instance of circular buffer • Execute producer, consumer in separate threads

28. Daemon Threads • Run for benefit of other threads • Do not prevent program from terminating • Garbage collector is a daemon thread • Set daemon thread with method setDaemon • Must be done at start time • Do not assign critical tasks to daemon thread • Will be terminated without warning • May prevent those tasks from completing properly

29. Runnable Interface • May be necessary to extend a class that already extends a class other than Thread • Java does not allow a class to extend more than one class at a time • Implement Runnable for multithreading support • Program that uses a Runnable object to control a thread • Creates a Thread object • Associates the Runnable object with that Thread class

30. Runnable Interface • Illustration of using a Runnable interface • Figure 23.18 • Note methods start, stop, run