Transcript Threads

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 platform
dependent!
• 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 by
another 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