Java threads: Introduction

1. Java threads: Introduction

2. Topics • background, motivation, and benefits of threads • what is a Java thread • how to start a thread • how to stop a thread (if possible) • on implementation of threads • scheduling policies, priorities, etc. • threads and interrupts • on interrupting and stopping threads

3. Concurrent programming in Java • in multiprocessing, multiple operating-system level processes are used to execute (independent) programs • the programs execute in their own (usually protected) memory spaces, using their own (virtual) CPUs • in multithreading, each thread also executes concurrently, with its own logical copy of CPU (program counter, registers, stack, cache, etc.), • however, all threads can potentially share and access the same data (global objects) in the program

4. Concurrent programming (cont.) • process ~ a concurrent execution of a program (e.g., the Java virtual machine) • thread ~ a concurrent control flow in the same program (process) • can involve either CPU interleaving vs. actual parallelism with multiple CPUs • "concurrent" activities may be only interleaved with the same CPU, or • execution can be truly parallel with multiple CPUs

5. Benefits of multithreading • to modularize the system by defining independent activities (to separate concerns, and to remove dependencies) • to model simultaneous activities taking place in the real world or in the system • receiving and dispatching GUI events(keyboard input, button clicks etc.) • animation, rendering graphical models, .. • to utilize idle waiting times for better performance • to increase responsiveness while occupied with any lenghty tasks, such as • IO, accessing e-mail, downloading files, etc.

6. What are Java threads? • threads are mostly independent activities • threads may need to share memory = objects in Java • multiple threads can use the same re-entrant code • but handling of shared objects must be protected by specially identified critical sections of code • each thread has its own program counter (PC) • a stack (plus registers, caches, ..) is needed for expression evaluation and method calls per thread • exceptions propagate along the call stack of an individual thread • if not caught, an exception causes the termination of that thread, only

7. Java concurrency features • API class java.lang.Thread, with the run () method as its "main" • so-called monitorlocks and condition (wait) queues • a lot of different synchronization facilities • threads may have priorities • threads are implemented by the JVM (Java Virtual Machine) but • their behaviour is heavily influenced by the underlying operating system and its characteristics • e.g., handling of scheduling, priorities, interrupting on-going IO activity, etc.

8. How to start a thread (1) public interface java.lang.Runnable { void run (); } class MyRunnable implements java.lang.Runnable { public void run () { task to be done. . } } new java.lang.Thread (new MyRunnable ()).start (); • start () creates a new execution context (program counter, stack, cache, etc.) for the new thread, and then returns, in the old thread

9. The Runnable interface • a Thread stores the reference to a Runnable, and when later started, begins to execute its run method • a single Runnable object may be shared by multiple threads that are thus executing the same code and possibly sharing the same data • we may use an inner Runnable class to define a task to be executed by a thread: runner = new Runnable () { public void run () { /* thread activity ... */ }}; new Thread (runner).start ();

10. How to start a thread (2) • you can also define a subclass of the Thread class class MyThread extends java.lang.Thread { public void run () { task to be done . . } new MyThread ().start (); • not recommended: better to decouple the task to run from the mechanism of running it • if you have many tasks, it may be too expensive to create a separate thread for each one of them • a thread reserves resources from the OS • too many threads may throttle the system

11. How to stop a thread • usually, a thread stops when its run method returns: public void run () { task to be done . . } • you cannot force a thread to stop from outside • such abort could cause undetermined state • instead, set a variable to indicate that the thread should stop; the thread itself checks this variable regularly, and can return from its run method in an orderly fashion • or, you can interrupt a waiting thread, see later

12. Daemon threads • a thread can be made a daemon thread before it is started: aThread.setDaemon (true); • daemons are service threads that execute background tasks (say, signaling timer events) • the program exits, when only daemons are left • there is no point in keeping the program running if all remaining threads are daemons • the GUI event thread is not a daemon (of course); a garbage collection could (possible) be..

13. Implementation of threads • the actual scheduling policy is system-dependent, and determined together by the host OS and the VM implementation: • scheduling between multiple threads may be preemptive using time-slicing techniques, so that activities become (randomly) interleaved • operating system may not guarantee fairness • or, in principle, it could be non-preemptive where each thread must itself voluntarily give turn to others • also called: "cooperative" • nowadays, less seldomly used

14. Implementation of threads (cont.) • historically, "green threads" were simulated threads within the VM and were used prior to Java 1.2 • not mapped to kernel threads provided by the OS • non-preemptive scheduling: yield or sleep • easier and more portable implementation • yield (): the currently executing thread object pauses and allows other threads to execute • "native threads" are provided by the host operating system • native threads can realize the performance enhancements, e.g., from parallelism (with multiple CPUs) • after Just-In-Time compiler (Java HotSpot VM), a Java thread corresponds to a native OS thread

15. Thread priorities • priority is between Thread.MIN_PRIORITY and Thread.MAX_PRIORITY • these are currently defined as 1 and 10, respectively • Thread.NORM_PRIORITY is currently defined as 5 • by default, a thread inherits its parent's priority, or a new priority may be specified: aThread.setPriority (newPriorityLevel); • usually, the scheduler tends to prefer higher-priority threads

16. Thread priorities (cont.) • however, the host platform may map these (ten) levels into fewer priority levels, or even ignore all priorities • Windows NT/XP had 7 priority levels; in some JVMs, all threads have the same priority • an apparently "lower"-priority thread may thus preempt a "higher"-priority thread • consequently, priorities can only be used to heuristically tune performance or enhance responsiveness • especially, thread priorities cannot be used to solve synchronization or exclusion problems in any portable way

17. Thread priorities (cont.) • furthermore, Java VM specification gives no guaranteeof general fairness in thread scheduling • but of course good implementations try to achieve it in their own ways • Thread.yield () is a hint that the current thread wouldn't mind giving processing time to other threads • in platforms with non-preemptive scheduling, yield is the main way to give other threads a chance to run • moreover, in some platforms, yield may be ignored, so generally Thread.sleep (delay) is a more reliable way to give turn to other threads

18. Interrupting threads • normally, a thread terminates when its run () returns • but you can try to interrupt it by: thread.interrupt (); • requests the thread to cancel its activities • when it feels itself ready for it.. • if a thread is running then its interrupted status flag will be set on to be tested by the thread • however, if a thread is somehow blocked, it cannot itself inspect for an interruption • if waiting (e.g., wait, sleep, or join), the interrupted thread throws the checked InterruptedException (the interrupt flag is not set on):

19. Interrupting threads (cont.) void run () { try { while (!Thread.interrupted () && more work) . . // may block and throw.. } catch (InterruptedException e) { . . // interrupted during its sleep or wait . . } finally { . . // cleanup in any case } } // exiting from run terminates the thread • InterruptedException is a checked exception, so you must catch it, or mark your methods with it

20. Interrupting threads (cont.) • thread.isInterrupted () tests the "interrupted" flag • Thread.interrupted () can be called only by the current thread itself and also cleares the flag • as always, it is bad style to just ignore exceptions: void mySubTask () { . . . try { . . . } catch (InterruptedException e) { } // DON'T . . . • tag the method to throw InterruptedException, or • at least call interrupt () again in the handler to set the interrupted status so that the caller can test it

21. Idioms for interrupting threads (1) if goes to sleep, no need to separately test the flag: try { . . . while (more work to do) {do more workThread.sleep (delay); // clears flag } } catch (InterruptedException e) { // handle interruption during sleep or wait } finally { cleanup, if required } • but interruptions are not errors but stop requests

22. Idioms for interrupting threads (cont.) (2) in a method, catch but don't "handle" and instead set the interrupted flag back on: try { . . Thread.sleep (delay); // clears flag } catch (InterruptedException e) { . . Thread.currentThread ().interrupt (); // set flag } // . . and test the flag somewhere else // any sleep or wait will again throw the exception • could also declare that the method throws, but then intermediate callers must handle the same possibility

23. Idioms for interrupting threads (cont.) (3) sometimes, can itself forward the "interrupted" state with an exception to be caught elsewhere: if (Thread.currentThread ().isInterrupted ()) throw new InterruptedException (); // don't clear Warning: anIO operation is either interrupted or not: may depend on the platform/implementation (see [Arnold et al., The Java Prog. Lang., 2006, p. 367]) • if a thread is blocked by a monitor lock, it won't throw InterruptedException but the flag is set on • the wait may later throw the interruption • special ReentrableLock objects (5.0) can throw, however..

24. Why cannot simply stop a thread • Java version 1.0methods stop (), suspend (), and resume () have been deprecated as unsafe • stop threw unchecked ThreadDeath that was meant not to be caught (but no guarantees) • a severe violation of exception safety: may break class invariants (in totally indeterministic way) • additionally, can cause deadlocks: a stopped thread may leave reserved resources • much safer solutions are provided by • a status variable that a thread checks itself, or • checked InterruptedException and the interrupted flag (with finally blocks to clean things up)

25. Thread groups • every thread belongs to a thread group, specified as a constructor parameter or, by default, inherited from the current thread (that is creating the new thread) • thread groups were part of the original impl. of threads, and were made available to users • the thread groups form a tree-like structure • can go through all threads in a group, set the max priority for a group, interrupt a whole group, manage security policies, or override uncaughtException method (since 5.0 also within the class Thread) • note that, since threads are objects, you can store, access, and control threads using any Java data structures + tools in package java.util.concurrent

26. Summary of Thread methods • new Thread (aRunnable): create with a Runnable • thread.start (): the thread starts executing • b = thread.isAlive (): is the thread in the Alive state • thread.interrupt (): set flag, or throw (when waiting) • b = thread.isInterrupted (): only test if the flag is set • otherThread.join (): waits that other thread finishes • otherThread.join (millis, nanos): waits with time-out • thread.setDaemon (b): set daemon / a user thread • b = thread.isDaemon (): test if this is a daemon • thread.setPriority (i): set priority (hint to scheduler) • i = thread.getPriority (): get priority • s = thread.toString (): name, priority, thread group,..

27. Summary of static Thread methods • the thread currently running a CPU (possibly many) current = Thread.currentThread (); • of course, each thread gets different result (itself) • also join (implicitly) affects current (waits for other) • b = Thread.interrupted (): test if the flag of the current thread is set; also clears the flag • Thread.sleep (millis, nanos): the current thread ceases execution for (at least) the given amout • the thread enters the Blocked state • Thread.yield (): the current thread "temporarily" pauses (but stays runnable) to give other threads a chance to run