程序代写代做代考 concurrency Java CO2017 — Week3L1 — Threads in Java
CO2017 — Week3L1 — Threads in Java
CO2017 — Week3L1 — Threads in Java
Dr Gilbert Laycock (gtl1)
2016–02–08
gtl1–R593 W3L1 — Java Threads 2016–02–08 1 / 17
Recap/overview
Recap and Lecture Overview
Recap
The nature of concurrent programming is multiple processes/threads
running in parallel
Processes may share resources
Solutions need to guarantee mutual exclusion, progress, bounded waiting
Overview of this lecture
How can Java support concurrent programming?
Java Thread class, and Runnable interface
Java ThreadGroup class, Executors and ThreadPools
Simple examples
gtl1–R593 W3L1 — Java Threads 2016–02–08 2 / 17
Concurrency in Java
Concurrency in Java
Java Virtual Machine (JVM) allows an application to have multiple
threads running concurrently
the thread concept is supported by
the classes java.lang.Thread and java.lang.ThreadGroup
the interface java.lang.Runnable
Two ways to create a new thread
Extending the Thread class
Implementing the Runnable interface
gtl1–R593 W3L1 — Java Threads 2016–02–08 3 / 17
Concurrency in Java
Two ways to create a thread
Extend Thread class
Implement Runnable class
MyRunnable
+run(): void
Thread
+run(): void
ExampleThread
+run(): void
Runnable
+run(): void
Thread
gtl1–R593 W3L1 — Java Threads 2016–02–08 4 / 17
Concurrency in Java Extend Thread class
Extending Java Thread Class
Declare a subclass of Thread, overriding its run() method
public class ExampleThread extends Thread {
int parameter;
ExampleThread(int para) { parameter = para; }
public void run() {
… // what the thread should do
}
}
Create an instance of the subclass and start executing it
ExampleThread t = new ExampleThread(10);
t.start();
gtl1–R593 W3L1 — Java Threads 2016–02–08 5 / 17
Concurrency in Java Implement Runnable interface
Implementing the Interface Runnable
Java does not permit multiple inheritance
So usually more convenient to implement run() from Java interface
Runnable instead of deriving from Thread
Runnable declares (just) the run() method
public interface Runnable {
public abstract void run();
}
We can extend other classes while implementing Runnable
In fact, the Thread class just implements Runnable
public class Thread
extends Object
implements Runnable
gtl1–R593 W3L1 — Java Threads 2016–02–08 6 / 17
Concurrency in Java Implement Runnable interface
Implementing the Interface Runnable (Cont’d)
First declare a class implementing Runnable
public class MyRunnable extends SomeClass
implements Runnable {
int parameter;
MyRunnable (int para) { parameter = para; }
public void run() {
… // what should the thread do?
}
}
Threads can then be allocated and started by
MyRunnable r = new MyRunnable(10);
Thread t = new Thread(r);
t.start();
gtl1–R593 W3L1 — Java Threads 2016–02–08 7 / 17
Concurrency in Java Thread methods
Methods of Thread Class
Some principal methods of the Thread class
t.start(): Causes thread t to begin execution; (JVM will call run()
concurrently)
t.run(): Call the run method of thread t directly (with no concurrency)
Thread.sleep(ms): Cease the execution of current thread for ms
milliseconds
t.join(): Causes the calling thread to wait (block) for the thread t to
finish
Refer to the Java documents about Thread class and Runnable
interface.
gtl1–R593 W3L1 — Java Threads 2016–02–08 8 / 17
Concurrency in Java Using threads
Outline code using Threads
public class T1 extends Thread {
// attributes and constructor
public void run() { /* thread functionality */ }
}
……
public class Tn extends Thread {
// attributes and constructor
public void run() { /* thread functionality */ }
}
public class MainProgram {
public static void main(String[] args) {
B;
T1 t1 = new T1(); …; Tn tn = new Tn();
t1.start(); …; tn.start();
I;
t1.join(); …; tn.join();
F; }
}
gtl1–R593 W3L1 — Java Threads 2016–02–08 9 / 17
Concurrency in Java Using threads
The Semantics of start()
The execution of B finishes before t1,. . . ,tn as they have not been
started yet;
The effect of t1.start(),. . . ,tn.start() is equivalent to interleaving
the atomic actions of the started threads;
Execution of statement I can interleave with t1,. . . ,tn
Execution of statement F does not begin until all of t1,. . . ,tn have
completed
Execution of main() terminates only if all of the started threads (and I
and F) terminate
If we replace t1.start(),. . . ,tn.start() with t1.run(),. . . ,tn.run(),
the program will become a sequential program
gtl1–R593 W3L1 — Java Threads 2016–02–08 10 / 17
Concurrency in Java Examples
Thread Example
class ExampleThread extends Thread {
int _id;
ExampleThread(int id) { _id = id; }
public void run() {
System.out.println(“This is thread: ” + _id);
}
public static void main(String[] args) {
ExampleThread t1 = new ExampleThread(42);
ExampleThread t2 = new ExampleThread(43);
ExampleThread t3 = new ExampleThread(44);
t1.start();
t2.start();
t3.start();
System.out.println(“All threads have terminated.”);
}
}
gtl1–R593 W3L1 — Java Threads 2016–02–08 11 / 17
Concurrency in Java Examples
Execution Result
A possible result is as follows:
This is thread 42
This is thread 43
All threads have terminated.
This is thread 44
The statements in main() after the start() statements can interleave
with the statements of the started threads.
The result is non-deterministic, and can differ with each run of the
program.
gtl1–R593 W3L1 — Java Threads 2016–02–08 12 / 17
Concurrency in Java Examples
Runnable example
class ExampleRunnable implements Runnable {
int _id;
ExampleRunnable(int id){ _id = id; }
public void run() {
System.out.println(“This is runnable thread: ” + _id);
}
public static void main(String[] args) {
Thread t1 = new Thread(new ExampleRunnable(42));
Thread t2 = new Thread(new ExampleRunnable(43));
Thread t3 = new Thread(new ExampleRunnable(44));
t1.start();
t2.start();
t3.start();
System.out.println(“All threads have terminated.”); }
}
gtl1–R593 W3L1 — Java Threads 2016–02–08 13 / 17
ThreadPoolExecutor Use ThreadPools to group and control threads
ThreadPoolExecutor
In order to control or synchronise the behaviour of threads, a thread
pool can be used
A thread pool represents a set of threads.
A thread can access info about its own thread pool.
Methods of Java ThreadPoolExecutor class include
Factory methods for creating new thread pools, e.g.
ex = (ThreadPoolExecutor)
Executors.newFixedThreadPoolExecutor(5);
int getActiveCount(): Returns the number of active threads in this
thread pool
Add a thread t to a pool ex by calling
Thread t = new Thread(Runnable r);
ex.execute(t);
gtl1–R593 W3L1 — Java Threads 2016–02–08 14 / 17
ThreadPoolExecutor ThreadPool example
ThreadPool Example
public class ThreadPoolMember implements Runnable {
// public class ThreadPoolMember extends Thread {
int _id;
ThreadPoolMember (int id) { _id = id; }
public void run() {
System.out.println(“This is thread: ” + _id);
try Thread.sleep(500); }
catch(InterruptedException e) {};
System.out.println(“This is thread: “+ _id +” again.”);
try { Thread.sleep(500); }
catch(InterruptedException e) {};
System.out.println(“Thread “+ _id +” has terminated.”);
gtl1–R593 W3L1 — Java Threads 2016–02–08 15 / 17
ThreadPoolExecutor ThreadPool example
ThreadPool Example (Cont’d)
public static void main(String[] args) {
ThreadPoolExecutor ex = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);
for (int i=42; i<=44; ++i) {
ThreadPoolMember t = new ThreadPoolMember(i);
ex.execute(t);
}
System.out.println(ex.getActiveCount()+" threads.");
while (ex.activeCount() > 0) {
try { Thread.sleep(100); } catch(InterruptedException e) {};
}
System.out.println(“All threads have terminated.”);
}
}
Program now outputs “All threads have terminated” only
after all threads actually terminated.
gtl1–R593 W3L1 — Java Threads 2016–02–08 16 / 17
Summary
Summary
Thread in Java can be created via:
Extending Thread class
Implementing Runnable interface
The result of running programs with multiple threads may be
non-deterministic
The Java ThreadPoolExecutor class can be used to collectively
manage the behaviour of threads
(Deprecated ThreadPool interface provides another mechanism to
control groups of threads.)
We have not yet really considered critical sections
gtl1–R593 W3L1 — Java Threads 2016–02–08 17 / 17
Concurrency in Java
Extend Thread class
Implement Runnable interface
Thread methods
Using threads
Examples
ThreadPoolExecutor
Use ThreadPools to group and control threads
ThreadPool example
