Threads

prettybadelyngeΛογισμικό & κατασκευή λογ/κού

18 Νοε 2013 (πριν από 3 χρόνια και 7 μήνες)

64 εμφανίσεις

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