Multithreading in Java

1. Multithreading in Java Project of COCS 513 By Wei Li December, 2000

2. Introduction: • Multithreading means the concurrent operation of • more than one path of execution within a computer. • Java is unique among popular general-purpose programming languages in that it makes concurrency primitives available to the application programmer. • Java multithreading refers to the ability of Java to support multiple threads of execution with in a single program.

3. Multithreading: General concepts • Process: • a program in execution • associated with data and execution context • an entity that can be assigned to CPU and executed • on it • controlled at kernel level • Thread: • a dispatchable unit of work within a process • can execute sequentially and can be interrupted • controlled at kernel level or user level

4. Multithreading: General concepts Multithreading: • Definition: • A technique in which threads of a process can run simultaneously • Benefits: • Give the programmer a greater control over the timing of • application related events • All threads within the same process can share the same data • and resources and share a part of the process’s execution • context • Save execution time comparing with multi-processes

5. Multithreading: General concepts One-process-one-thread model: Process Control Block User Address Space User Stack Kernel Stack Process control block: • Process identification • Processor state information( i.e., register information and stack pointer) • Process control information(i.e., scheduling and state information, • data structuring, process privileges, memory management, etc..)

6. Multithreading: General concepts One process multiple threads model: Thread Control Block User Stack Kernel Stack Process Control Block User Address Space Thread Control Block User Stack Kernel Stack Process control block: Thread control block: 1. Process identification 1. Thread register image 2. Processor state information 2. Thread priority • 3. Process control information 3. Thread state information

7. Multithreading: General concepts Time schedule of execution (i.e. a Java program with two threads) : • One process one thread model : thread1 is blocked thread1 is dead thread1 runs Time thread1 continues thread2 begin to run • One process multiple threads model: thread1 is blocked CPUTime needed to Execute the program thread1: thread1 continues thread1 runs thread2: Blocked or dead thread1 running thread2 into running state Time thread2 running

8. Multithreading in Java: Program Thread states: At any time, a thread is in one of several states. Some switches can be decided at editing program, others occur when some conditions meet at Java run-time environment. The conditions can be set by programmers or the operating system. Runnable Blocked Born 1: start 2: yield 3: notify or notifyAll 4: wait 5: sleep 3 1 Ready Waiting Sleeping 2 4 Dead 5 BlockingI/O Running switch using an explicit command switch when some conditions meet

9. Multithreading in Java: Program The methods used with threads • Start: This method launches a thread to enter the ready state and begins to invoke related run method. • Run: The code inside executes the “real work” of a thread. • Wait: When a running method calls wait method the thread • enters a waiting state for particular object in which the thread was running. • Notify: A thread in the waiting state for a particular object becomes ready on a call to notify issued by another thread associated with that object. • Sleep:This gives lower-priority threads a chance to run. A sleeping thread becomes ready after the designated sleep timeout. • Yield: A thread can call yield to give other threads a chance to execute.

10. Multithreading in Java: Program Edit a subclass into a thread: approach 1 A subclass by inheriting Java class Thread (package java.lang) and overriding its run method to realize multithreading, i.e., Class TimePrinter extends Thread {…} Edit a subclass into a thread: approach 2 An subclass by implementing Java interface Runnable and automatically take run method. It has to be run from within an instance of Thread class, i.e., Class TimePrinter extends JApplet implements Runnable { … Thread thread1 = new Thread( new TimePrinter (…)); thread1.start(); }

11. Multithreading in Java: Program Synchronizing Threads: • Prevent collisions in which more than one thread attempts to • modify the same object at the same time. • Java Object class provides each object a lock. The lock can be • manipulated only by JVM (Java Virtual Machine) and allow only • one thread at a time to access the object. • Synchronizingin Java program is at object level. For convenience, • synchronized keyword can be used as a method modifier. If one • thread is locked by calling the synchronized method in an object, • the all methods in this object can not be invoked by other threads. • Use wait and notify (or notifyAll) to realize threads coordinating

12. Multithreading in Java: Program A example of using “synchronized” keyword: public class Account{ float amount; public Account() {…} Public synchronized void deposit ( float amt){ amount +=amt; } Public synchronized void withdraw (float amt){ amount -=amt; } }

13. Multithreading in Java: multithreading models Multithreading implementation • The steps of editing, compiling and interpreting multithreads • can be thought as Java application. • Two main categories of multiple threads implementation : • User level threads (ULT) • Kernel level threads (KLT) • The mapping of multithreads from the user level to the kernel • level can be divided as three models: • Many-to-One (multiple ULTs to one KLT) • One-to-One (one ULT to one KLT) • Many-to-Many (multiple ULTs to multiple KLTs)

14. Multithreading in Java: multithreading models Many-to-One model: Green threads in Solaris LWP CPU Kernel User space Kernel space Java application (Green threads) (JVM)

15. Multithreading in Java: multithreading models Many-to-One: Green threads in Solaris • Multiple ULTs to one KLT • Threads library is stored in Java Development Kit (JDK). Thread library is a package of code for user level thread management, i.e. scheduling thread execution and saving thread contexts, etc.. In Solaris threads library is called “green threads”. • Disadvantages : • One thread is blocked, all threads are blocked • Can not run on multiprocessors in parallel

16. Multithreading in Java: multithreading models One-to-One model: in Windows NT LWP LWP CPU Kernel Kernel space User space Java Application (JVM)

17. Multithreading in Java: multithreading models One-to-One model: in Windows NT • One ULT to one KLT • Realized by Windows NT threads package. • The kernel maintains context information for • the process and for individual thread. • Disadvantage: • The time of switching one thread to another thread at • kernel level is much longer than at user level.

18. Multithreading in Java: multithreading models Many-to-Many model: Naive threads in Solaris LWP LWP CPU Kernel Kernel space User space Java Application (Native threads)

19. Multithreading in Java: multithreading models Many-to-Many model: Native threads in Solaris • Two level model or combined model of ULT and KLT • In Solaris operating system, native threads library can be • invoked by setting THREADS_FLAG in JDK to native environment. • A user level threads library (Native threads), provided by JDK, • can schedule user-level threads above kernel-level threads. • The kernel only need to manage the threads that are currently • active. • Solve the problems in two models above

20. Multithreading in Java: Conclusion • Multithreading is one of the most important features in Java. • Using multithreading, the execution of different threads • in a process can be realized at the same time. • In Java programming, multithreading means the application • of class Thread. • In implementation, multithreading means some models • of mapping threads from the user level to the kernel level. • The mapping models are operating system dependent.