Transcript javaProgLec09

Concurrency (Threads)
Threads allow you to do tasks in parallel.
In an unthreaded program, you code is
executed procedurally from start to finish.
In a threaded program, you can have
multiple threads working concurrently.
Threads are short-lived
Threads are like processes, only they're
short-lived.
How short-lived?
– When run() method terminates or returns
– The thread is interrupted
– An exception is thrown inside run()
Process vs. Threads
Process: A process runs independently and isolated of
other processes. It cannot directly access shared data
in other processes. The resources of the process are
allocated to it via the operating system, e.g. memory
and CPU time.
Threads: threads are so-called lightweight processes which
have their own call stack but can access shared data.
Every thread has its own memory cache. If a thread
reads shared data it stores this data in its own
memory cache.
Concurrency (Threads)
Concurrency is achieved through timeslicing. This is where the processor cycles
through each active thread for an
indeterminate period of time (the slice).
This gives the illusion that there are
multiple processes.
With multi-core processors, this may mean,
true multi-threading is possible, but NOT
guaranteed
Amdahl's Law
Concurrency promises to perform certain task
faster as these tasks can be divided into
subtasks and these subtasks can be executed
in parallel. Of course the runtime is limited by
parts of the task which can be performed in
parallel. The theoretical possible performance
gain can be calculated by Amdahl's Law. If F is
the percentage of the program which can not
run in parallel and N is the number of
processes then the maximum performance
gain is:
1/ (F+ ((1-F)/n)).
Issues in Concurrency
A visibility problem occurs if one thread
reads shared data which is later
changed by other thread and if thread A
does not see this change.
A access problem occurs if several thread
trying to access and change the same
shared data at the same time.
Concurrency Failures
Liveness failure: The program does not
react anymore due to problems in the
concurrent access of data, e.g.
deadlocks.
Safety failure: The program creates
incorrect data.
Syncrhonized keyword
that only a single thread can execute a block
of code at the same time
ensures that each thread entering a
synchronized block of code sees the
effects of all previous modifications that
were guarded by the same lock
Volatile keyword
If a variable is declared as volatile then it is
guaranteed that any thread which reads
the field will see the most recently
written value. This is to guard against
caching.
Thread Pools
Thread Pools manage (and limit) the
number of active threads. This tends to be
more orderly and more efficient for scaled
applications.
Synchronizing methods
When multiple threads have access to the
same object, it makes sense to
synchronize those methods which are
prone to concurrency errors.
The bank account example.
Thread-safe collections
//http://download.oracle.com/javase/6/docs/a
pi/java/util/concurrent/packagesummary.html
Running a Thread
• Implement a class that implements the Runnable interface:
public interface Runnable
{
void run();
}
• Place the code for your task into the run method of your class:
public class MyRunnable implements Runnable
{
public void run()
{
Task statements
...
}
}
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Running a Thread
• Create an object of your subclass:
Runnable r = new MyRunnable();
• Construct a Thread object from the runnable object:
Thread t = new Thread(r);
• Call the start method to start the thread:
t.start();
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Running Threads
• sleep puts current thread to sleep for given number of
milliseconds:
Thread.sleep(milliseconds)
• When a thread is interrupted, most common response is to
terminate run
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Generic run method
public void run()
{
try
{
Task statements
}
catch (InterruptedException exception)
{
}
Clean up, if necessary
}
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
ch20/greeting/GreetingRunnable.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Date;
/**
A runnable that repeatedly prints a greeting.
*/
public class GreetingRunner implements Runnable
{
private static final int REPETITIONS = 10;
private static final int DELAY = 1000;
private String strGreeting;
/**
Constructs the runnable object.
@param aGreeting the greeting to display
*/
public GreetingRunner(String strGreeting)
{
this.strGreeting = strGreeting;
}
Continued
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
To Start the Thread
• Construct an object of your runnable class:
Runnable t = new GreetingRunnable("Hello World");
• Then construct a thread and call the start method:
Thread t = new Thread(r);
t.start();
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Thread Scheduler
• Thread scheduler: runs each thread for a short amount of time
(a time slice)
• Then the scheduler activates another thread
• There will always be slight variations in running times especially when calling operating system services (e.g. input
and output)
• There is no guarantee about the order in which threads are
executed
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Terminating Threads
• A thread terminates when its run method terminates
• Do not terminate a thread using the deprecated stop method
• Instead, notify a thread that it should terminate:
t.interrupt();
• interrupt does not cause the thread to terminate – it sets a
boolean variable in the thread data structure
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Terminating Threads
• The run method should check occasionally whether it has been
interrupted
• Use the interrupted method
• An interrupted thread should release resources, clean up, and exit:
public void run()
{
for (int i = 1;
i <= REPETITIONS && !Thread.interrupted();
i++)
{
Do work
}
Clean up
}
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Terminating Threads
• Java does not force a thread to terminate when it is interrupted
• It is entirely up to the thread what it does when it is interrupted
• Interrupting is a general mechanism for getting the thread’s
attention
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.
Synchronizing Object Access
• When a thread calls lock, it owns the lock until it calls unlock
• A thread that calls lock while another thread owns the lock is
temporarily deactivated
• Thread scheduler periodically reactivates thread so it can try to
acquire the lock
• Eventually, waiting thread can acquire the lock
Big Java by Cay Horstmann
Copyright © 2009 by John Wiley & Sons. All rights reserved.