Bài giảng Nhập môn lập trình Java - Bài 10: Multi-threading - Võ Tấn Dũng

GIẢNG VIÊN:
VÕ TẤN DŨNG
NHẬP MÔN JAVA
BÀI 10
MULTI-THREADING
TRƯỜNG CAO ĐẲNG CÔNG NGHỆ THÔNG TIN TP.HCM
2G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
NỘI DUNG
• Đa nhiệm và đa tuyến
• Tạo lập và sử dụng tuyến
– Lớp Thread
– Giao tiếp Runnable
• Đồng bộ hoá các tuyến
• Tuyến ma
• Nhóm tuyến
3G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Đa nhiệm (multitasking)
• Đa nhiệm là kỹ thuật cho phép nhiều công việc được
thực hiện cùng một lúc trên máy tính.
• Nếu có nhiều CPU, các công việc có thể được thực hiện
song song trên từng CPU. Trong trường hợp nhiều công
việc cùng chia sẻ một CPU, từng phần của mỗi công
việc sẽ được CPU thực hiện xen kẽ.
4G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Đa nhiệm (multitasking)
• Hai kỹ thuật đa nhiệm cơ bản:
– Đa tiến trình (Process-based multitasking): 
Nhiều chương trình chạy đồng thời. Mỗi 
chương trình có một vùng dữ liệu độc lập.
– Đa tuyến (Thread-based multitasking): Một 
chương trình có nhiều tuyến cùng chạy đồng 
thời. Các tuyến dùng chung vùng dữ liệu của 
chương trình.
5G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tuyến và đa tuyến
• Tuyến là mạch thi hành độc lập của một tác vụ
trong chương trình.
• Một chương trình có nhiều tuyến thực hiện cùng
lúc gọi là đa tuyến.
6G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến
• Tuyến trong Java cũng là các đối tượng.
• Có hai cách để tạo tuyến
– Thừa kế từ lớp java.lang.Thread
– Cài đặt giao tiếp java.lang.Runnable
7G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến - Cách 1: Kế thừa từ Thread
8G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến - Cách 1: Kế thừa từ Thread
• Khi một tuyến được tạo ra, nó cần gọi start() để
đặt tuyến ở trạng thái sẵn sàng. Tiếp theo hệ
thống sẽ thực thi các câu lệnh trong run() của
tuyến đó.
• Tuyến sẽ kết thúc khi làm hết lệnh trong run()
hoặc khi stop() được gọi.
9G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến - Cách 1: Kế thừa từ Thread
10
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến - Cách 2: Cài đặt Runnable
11
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Độ ưu tiên
• Các tuyến trong Java có độ ưu tiên 
từThread.MIN_PRIORITY (giá trị 1) đến 
Thread.MAX_PRIORITY (giá trị 10)
• Tuyến có độ ưu tiên càng cao thì càng sớm 
được thực hiện và hoàn thành.
• Độ ưu tiên mặc định của các tuyến là 
Thread.NORM_PRIORITY (giá trị 5).
• Một tuyến mới sẽ thừa kế độ ưu tiên từ tuyến 
tạo ra nó.
12
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Bộ lập lịch
• Bộ lập lịch (scheduler) của Java quản lý các tuyến theo 
cơ chế phân chia thời gian (timeslicing).
• Từng tuyến sẽ được cấp một khoảng thời gian ngắn 
(time quantum) để sử dụng CPU.
• Trong khi thực thi, nếu đã hết thời gian được cấp thì dù 
chưa kết thúc tuyến cũng phải tạm dừng để cho các 
tuyến khác cùng độ ưu tiên dùng CPU.
• Các tuyến cùng độ ưu tiên luân phiên sử dụng CPU theo 
kiểu xoay vòng (round-robin).
13
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Bộ lập lịch
• Ví dụ: Tuyến A và B sẽ luân phiên
nhau thực thi cho đến khi kết thúc.
Tiếp theo tuyến C sẽ thực thi đến
khi kết thúc.
• Tiếp theo tuyến D, E và F sẽ luân
phiên thực thi đến khi kết thúc.
Tiếp theo tuyến G thực thi đến khi
kết thúc. Cuối cùng tuyến H và I
luân phiên thực thi đến khi kết
thúc.
• Nhận xét:Các tuyến có độ ưu tiên
thấp sẽ có nguy cơ bị trì hoãn vô
hạn định.
14
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về đa tuyến
• Tạo ra 3 tuyến với độ ưu tiên mặc định.
• Công việc của mỗi tuyến là ngủ trong một 
thời gian ngẫu nhiên từ 0 đến 5 giây. Sau 
khi ngủ xong, các tuyến sẽ thông báo ra 
màn hình.
15
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về đa tuyến (tt)
class PrintThread extends Thread {
private int sleepTime;
public PrintThread( String name ){
super( name );
sleepTime = (int)(Math.random()*5000);
System.out.println( getName() + 
" have sleep time: " + sleepTime); 
}
16
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về đa tuyến (tt)
// method run is the code to be executed by new thread
public void run(){
try{
System.out.println(getName()+“ starts to sleep");
Thread.sleep( sleepTime );
} 
//sleep() may throw an InterruptedException
catch(InterruptedException e){
e.printStackTrace();
} 
System.out.println( getName() + " done sleeping" );
}
}
17
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về đa tuyến (tt)
public class ThreadTest{
public static void main( String [ ] args ){
PrintThread thread1 = new PrintThread( "thread1" );
PrintThread thread2 = new PrintThread( "thread2" );
PrintThread thread3 = new PrintThread( "thread3" );
System.out.println( "Starting threads" );
thread1.start(); //start and ready to run
thread2.start(); //start and ready to run
thread3.start(); //start and ready to run
System.out.println( "Threads started, main ends\n" );
}
}
18
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về đa tuyến (tt)
19
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Một số phương thức của Thread
• void sleep(long millis); // ngủ
• void yield(); // nhường điều khiển
• void interrupt(); // ngắt tuyến
• void join(); // yêu cầu chờ kết thúc
• void suspend(); // deprecated
• void resume(); // deprecated
• void stop(); // deprecated
20
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Vòng đời của tuyến
21
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Đồng bộ hóa tuyến
• Việc các tuyến trong chương trình cùng truy nhập
vào một đối tượng có thể sẽ đem lại kết quả không
như mong muốn. Ví dụ: Tuyến A cập nhật đối tượng
X và tuyến B đọc dữ liệu từ X. Rất có thể xảy ra sự
cố là tuyến B đọc dữ liệu chưa được cập nhật.
• Đồng bộ hoá tuyến (thread synchronization) giúp
cho tại mỗi thời điểm chỉ có một tuyến có thể truy
nhập vào đối tượng còn các tuyến khác phải đợi. Ví
dụ: Trong khi tuyến A cập nhật X thì tuyến B chưa
được đọc.
22
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Đồng bộ hóa tuyến
• Dùng từ khoá synchronized trên các phương
thức để thực hiện đồng bộ hoá.
• Đối tượng khai báo phương thức synchronized
sẽ có một bộ giám sát (monitor). Bộ giám sát
đảm bảo tại mỗi thời điểm chỉ có một tuyến
được gọi phương thức synchronized.
• Khi một tuyến gọi phương thức synchronized,
đối tượng sẽ bị khoá. Khi tuyến đó thực hiện
xong phương thức, đối tượng sẽ được mở
khoá.
23
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Đồng bộ hóa Thread
• Trong khi thực thi phương thức synchronized,
một tuyến có thể gọi wait() để chuyển sang trạng
thái chờ cho đến khi một điều kiện nào đó xảy
ra. Khi tuyến đang chờ, đối tượng sẽ không bị
khoá.
• Khi thực hiện xong công việc trên đối tượng,
một tuyến cũng có thể thông báo (notify) cho các
tuyến khác đang chờ để truy nhập đối tượng.
• Deadlock: Tuyến A chờ tuyến B và tuyến B cũng
chờ tuyến A.
24
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Quan hệ Producer - Consumer
• Giả sử có 2 tuyến: Producer ghi dữ liệu vào một
buffer và Consumer đọc dữ liệu từ buffer
=> Cần có sự đồng bộ hoá nếu không dữ liệu có
thể bị Producer ghi đè trước khi Consumer đọc
được hoặc Consumer có thể đọc một dữ liệu
nhiều lần khi Producer chưa sản xuất kịp.
25
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Quan hệ Producer - Consumer
• Giải pháp đồng bộ hoá:
– Trước khi tiếp tục sinh dữ liệu và đưa vào buffer,
Producer phải chờ (wait) Consumer đọc xong dữ liệu
từ buffer.
– Khi Consumer đọc xong dữ liệu, nó sẽ thông báo
(notify) cho Producer biết để tiếp tục sinh dữ liệu.
– Nếu Consumer thấy trong buffer không có dữ liệu
hoặc dữ liệu đó đã được đọc rồi, nó sẽ chờ (wait) cho
tới khi nhận được thông báo có dữ liệu mới.
– Khi Producer sản xuất xong dữ liệu, nó thông báo
(notify) cho Consumer biết.
26
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Không đồng bộ
class Buffer{
private int buffer = -1;
public void set( int value ){
buffer = value;
}
public int get(){
return buffer; 
}
}
27
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Không đồng bộ
class Producer extends Thread
{
private Buffer sharedBuffer;
public Producer( Buffer shared )
{
super( "Producer" );
sharedBuffer = shared;
}
28
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Không đồng bộ
public void run(){
for ( int count = 1; count <= 5; count++ ){
try{
Thread.sleep((int)(Math.random() * 3000));
sharedBuffer.set( count );
System.out.println( "Producer writes " + count);
} catch (InterruptedException e){
e.printStackTrace();
}
}
System.out.println( getName() + " finished.");
}
}
29
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Không đồng bộ
class Consumer extends Thread
{
private Buffer sharedBuffer;
public Consumer( Buffer shared )
{
super( "Consumer" );
sharedBuffer = shared;
} 
30
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Không đồng bộ
public void run(){
for ( int count = 1; count <= 5; count++ ){
try{
Thread.sleep((int)(Math.random() *3000));
System.out.println( "Consumer reads " +
sharedBuffer.get());
}catch (InterruptedException e){
e.printStackTrace();
}
}
System.out.println( getName() + " finished.");
}
}
31
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Không đồng bộ
public class SharedBufferTest1{
public static void main( String [] args ){
//create shared object used by threads
Buffer sharedBuffer = new Buffer();
//create producer and consumer objects
Producer producer=new Producer(sharedBuffer);
Consumer consumer=new Consumer(sharedBuffer);
producer.start(); // start producer thread
consumer.start(); // start consumer thread
}
}
32
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Kết quả khi không đồng bộ
33
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Có đồng bộ
class Buffer{ // Thiết kế lại lớp Buffer
private int buffer = -1;
private boolean writable = true;
public synchronized void set( int value ){
while (!writable){
try{
wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
buffer = value;
writable = false;
notify();
}
34
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ về P - C: Có đồng bộ
public synchronized int get(){
while( writable ){
try{
wait();
} catch (InterruptedException e){
e.printStackTrace();
}
}
writable = true;
notify();
return buffer;
}
}
35
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Kết quả khi có đồng bộ
36
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến từ giao tiếp Runnable
• Một lớp có thể trở thành một tuyến khi cài đặt
giao tiếp Runnable (giao tiếp này chỉ có một
phương thức run() duy nhất).
• Ví dụ: Tạo applet có quả bóng chạy
37
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến từ giao tiếp Runnable
import java.awt.*;
import java.applet.*;
public class BallFlyingextendsApplet implements Runnable{
Thread animThread = null;
int ballX= 0, ballY=50;
int dx=1, dy=2;
boolean stopRun = false;
public void start(){ //applet starts
if (animThread == null){
animThread= new Thread(this);
animThread.start();
}
}
38
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến từ giao tiếp Runnable
public void stop(){ // applet stops
stopRun = true;
}
publicvoid run(){
this.setBackground(Color.CYAN);
while (! stopRun){
moveBall(); 
delay(5);
}
}
private void delay(intmiliSeconds){
try{
Thread.sleep(miliSeconds);
}catch (Exception e){
System.out.println("Sleeperror !");
}
}
39
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Tạo tuyến từ giao tiếp Runnable
private void moveBall(){
ballX += dx;
ballY += dy;
if (ballY> getSize().height -30) dy =- dy;
if (ballX> getSize().width -30) dx =- dx; 
if (ballY< 0) dy =- dy; 
if (ballX< 0) dx =- dx; 
repaint();
}
publicvoid paint(Graphicsg){
g.fillOval(ballX,ballY, 30, 30);
}
}
40
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
• Tuyến ma thường là tuyến hỗ trợ môi trường thực
thi của các tuyến khác. Ví dụ: garbage collector của
Java là một tuyến ma.
• Chương trình kết thúc khi tất cả các tuyến không
phải tuyến ma kết thúc.
• Các phương thức với tuyến ma:
– void setDaemon(boolean isDaemon); // đặt tuyến
trở thành tuyến ma
– boolean isDaemon(); // kiểm tra tuyến có phải
tuyến ma không
Tuyến ma (daemon thread)
41
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Nhóm tuyến (thread group)
• Các tuyến có thể được đưa vào trong cùng một
nhóm thông qua lớp ThreadGroup. Ví dụ: nhóm
tuyến tìm kiếm dữ liệu trên các tập dữ liệu khác
nhau.
• Một nhóm tuyến chỉ có thể xử lý trên các tuyến
trong nhóm, ví dụ: ngắt tất cả các tuyến.
• Có thể tạo ra các nhóm tuyến là nhóm con của
một nhóm tuyến khác.
• Nhóm tuyến đặc biệt: system, main
42
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Lớp Timer
• Hai lớp liên quan tới xử lý công việc theo thời
gian:
– javax.swing.Timer
– java.util.Timer
• Lớp java.swing.Timer
– Đơn giản, dễ dùng trên GUI
• Lớp java.util.Timer
– Nhiều tính năng hơn java.swing.Timer
43
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ: Đếm ngược
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class CountDown extends Applet implements 
ActionListener{
private TextField timeField; 
private Button startButton;
private Button stopButton;
private javax.swing.Timer timer;
private int count;
public void init(){
timeField = new TextField(6);
44
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ: Đếm ngược
timeField.setFont(new Font("sansserif", Font.PLAIN, 18));
startButton = new Button("Start");
stopButton = new Button("Stop");
add(timeField); 
add(startButton);
add(stopButton);
startButton.addActionListener(this);
stopButton.addActionListener(this);
timer = new javax.swing.Timer(10, this);
count = 0;
} // end init()
45
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g
Ví dụ: Đếm ngược
public void actionPerformed(ActionEvent e){
if (e.getSource() == startButton)
timer.start();
else if (e.getSource() == stopButton)
timer.stop();
else {
count++;
int hsecond = count%100;
int totalSecond = (count/100);
int h = totalSecond/3600;
int secondLeft = totalSecond%3600;
int m = secondLeft/60;
int s = secondLeft%60;
timeField.setText("“ + h + ":" + m + ":" + s + ":" + hsecond);
}
}
}
HẾT
BÀI 10
G
V
: 
V
õ
 T
ấ
n
 D
ũ
n
g