Thread basics

A computer process

• Every time a program is executed a process is created

• It is managed via a data structure that keeps all things memory related– Global address space– File-handle table– Heap data

A computer process

• When swapping processes for execution:– All things in that d.s. have to be brought to disk– Large chunks of memory contents

• Process lots of memory• Swapping processes is expensive, lots of

memory have to be moved around.• Swapping (context swapping) is measured

in seconds

Thread

• Sequence of byte code instructions executed by the JVM; thus a thread consists of two things:– A sequence of code– Its execution

• This sequence forms a path of code through a program sequence

• No notion of objects or methods here• Sequences of instructions (threads) can overlap,

also they can execute simultaneously on multiple threads

Thread data structure

• It contains data to keep track of this sequence and its execution– Contents of the registers– Position of execution in the instruction

sequence– Run-time stack (LIFO) made up of activation

records (created for methods to contain local variables, parameters, return pointer)

– Life-time: threads are created and terminated.

Swapping threads

• OS typically swaps a thread– Push registers on the thread’s stack– Add thread d.s. to an OS list– Pull a different thread’s d.s off that list– Pop thread’s local stack into register set.

• Thread swapping is measured in milliseconds. – Thus: threads are lightweight processes

• A process is equivalent to Java’s virtual machine• A thread is process state, ie a virtual machine state.

Threads and Processes• Important: threads share the memory allocated to the process. • Thus, given two threads:

– May share instruction sequence– May share memory

• As a consequence:– Two threads may share program’s data and methods to modify it

• This is what makes threads hard to program. You need to carefully design for:– The commands executed by possibly multiple threads– The queries executed by possibly multiple threads– The time when that execution must occur.

• How to design threaded programming: – By synchronizing (locking) the actions caused by each thread that

shares data with other threads.

Managing threads

• If a thread manipulates data that is not shared by any other thread, no need to manage this sequence of execution, no need for synchronization.

• Example of such case. Given two threads, each has its own stack:– Two threads do not share methods local variables and

parameters.

• If a method does not access any heap data ( thus no access to objects and their fields), it can be executed simultaneously by multiple threads without explicit synchronization.

Multi-threaded programming

• Modern OS allow multiple threads to be running concurrently within a process.

• When JVM is started– A new process is created– Many threads can be created (spawned) in it.– One thread spawned is the thread having as

execution sequence given by the “main”.

Default threads in JVM

• The “main” thread:– Spawned by the JVM when the process is

created. – Beginning sequence is given by the main().– Executes all statements in main()– Dies when main() completes execution.

Default threads in JVM

• The “garbage collection” thread:– Spawned by the JVM when the process is

created. – The sequence of code it executes is the code

written to discard objects and reclaim memory.

• Thus any Java program has at least two threads executing: we say that a Java program runs in a multi-threaded environment.

Default threads in JVM

• If the program contains a GUI interface a new thread is created: The “event-handling” thread: The sequence of instructions it executes is – the code associated with listeners.– Events coming from the OS.

• This means that if this thread is executing code of a listener, any mouse click or key press is put on hold until this thread terminates what is doing.

• As a consequence we have an unresponsive user interface: one that appears to hang.

Thread safety• The phrase “thread safe” is used to describe a

method that can run safely in a multi-threaded environment– Accesses process-level data (shared memory by several

processes) in a safe and efficient way.

• The goal in designing multi-threaded programs is to achieve thread safety among other properties.

• This is usually a hard goal to achieve, one you must design up-front about, and one whose bugs are not only hard to pin-point but difficult to remove.

Why multi-threaded programming?

• Better interaction with user• Simulation of simultaneous activities in one

processor machine• Exploitation of multi-processor machines• Execution of computation code while doing I/o.

Specially useful in network programming.• Allow multiple user to execution same code

simultaneously . Specially useful in network programming.

• Better Object oriented design.

Why understanding and using threads

• All nontrivial applications for the Java platform are multithreaded, whether you like it or not.

• It's not ok to have an unresponsive UI.

• It’s not ok for a server to reject requests.

When multi-threaded programming might not be good

• Threads carry overhead both in space and time.

• Thread management.

• All this cost must be considered when considering designing for threads.

Thread behavior is platformdependent!

• You need to use the OS threading system to get parallelism (vs. concurrency)– Different operating systems use different

threading models (more in a moment).– Behavior often based on timing.– Multi-threaded apps can be slower than

single-threaded apps (but be better organized)

Priorities

• The Java™ programming language has 10 levels• The Solaris™ OS has 2 31 levels• NT™ offers 5 (sliding) levels within 5 "priority classes."• NT priorities change by magic.

– After certain (unspecified) I/O operations priority is boosted(by an indeterminate amount) for some (unspecified) time.

– Stick to Thread.MAX_PRIORITY,– Thread.NORM_PRIORITY,Thread.MIN_PRIORITY)

Threading models

• Cooperative (Windows 3.1)– A Thread must voluntarily relinquish control of the CPU.– Fast context swap, but hard to program and can’t

leveragemultiple processors.• Preemptive (NT)

– Control is taken away from the thread at effectively random times.

– Slower context swap, but easier to program and multiple threads can run on multiple processors.

• Hybrid (Solaris™ OS, Posix, HPUX, Etc.)– Simultaneous cooperative and preemptive models are

supported.

Do not assume a particular environment

• Assume both of these rules, all the time:– A thread can prevent other threads from

running if it doesn't occasionally yield• by calling yield(), performing a blocking I/O

operation, etc.

– A thread can be preempted at any time byanother thread

• even by one that appears to be lower priority than the current one.

Conclusion

• Easy to start using threads, VERY tough to master.

• Designing classes that contain methods that are thread safe is a challenge.

• Read: javadoc for the class java.lang.Thread