Giáo trình Kỹ thuật phần mềm - Chương 6: Đa luồng - Phạm Duy Trung

ĐA LUỒNG Multithreading duytrung.tcu@gmail.com Nội dung bài học • Thread • Vòng đời của thread • Multithreading • Xếp lịch chạy cho thread • Thread safe • Deadlock • Lock và synchronized • SwingWorker duytrung.tcu@gmail.com Thread là gì • Thread /θred/ • Thread là một tiến trình hạng nhẹ (lightweight process), là luồng logic tuần tự các lệnh chương trình, với một điểm bắt đầu và một điểm kết thúc • Trong vòng đời của mình, thread chỉ được thực thi một lần duy nhất • Bản thân thread không phải là một chương trình, nó không chạy độc lập mà nằm trong một chương trình hoàn chỉnh duytrung.tcu@gmail.com Thread là gì • Một chương trình có thể là đơn luồng (single-thread) hoặc đa luồng (multi-thread) • Đơn luồng: 1 điểm vào và 1 điểm ra • Đa luồng: 1 điểm bắt đầu ở main(), sau đó là nhiều điểm vào và nhiều điểm ra chạy song hành với main() duytrung.tcu@gmail.com Đa nhiệm (Multitasking / Multi-processing) • Đa số các HĐH hiện nay là đa nhiệm • Thực hiện đồng thời nhiều công việc dựa trên chia sẻ tài nguyên: CPU, bộ nhớ, các kênh vào ra • Với CPU đơn nhân: chỉ một tác vụ được thực hiện tại một thời điểm, xếp lịch trên các khe thời gian (time slice) duytrung.tcu@gmail.com Đa nhiệm (Multitasking) • Với CPU đa nhân: nhiều tác vụ có thể chạy song song trên các CPU khác nhau • Về cơ bản, có 2 dạng đa nhiệm: 1. Đa nhiệm hợp tác: mỗi tác vụ sử dụng tài nguyên hệ thống cho đến khi thực hiện xong thì nhường cho tác vụ khác 2. Đa nhiệm ưu tiên: mỗi tác vụ được cấp một khe thời gian, nhường điều khiển cho tác vụ khác khi dùng hết tài nguyên của mình duytrung.tcu@gmail.com Đa luồng (Multithreading) • Xét trong một tiến trình (process) hay chương trình (program) • Một tiến trình có bộ nhớ lệnh và các khối điều khiển riêng • Tiến trình có thể chạy nhiều luồng để nâng cao hiệu quả • Các luồng chạy trong ngữ cảnh của tiến trình, cùng chia sẻ các tài nguyên được cấp cho tiến trình • Các luồng chỉ chạy trong ngữ cảnh cụ thể của tiến trình, khi chạy các luồng sử dụng stack, thanh ghi và bộ đếm chương trình của riêng mình duytrung.tcu@gmail.com Tại sao sử dụng thread • Tận dụng tối ưu hơn tài nguyên của hệ thống  Khi một luồng đang bị đình chỉ, do đang chờ đọc dữ liệu từ một cổng vào/ra, luồng khác có thể sử dụng CPU để tính toán, mang lại kết quả thực hiện tốt hơn • Giúp nâng cao hiệu quả tương tác của chương trình với người sử dụng  Khi soạn thảo văn bản, một thread sẽ đảm nhiệm khi ta ấn lưu file, trong quá trình lưu thread khác tiếp tục thực hiện cho người dùng nhập văn bản -> giao diện người dùng đáp ứng tốt – Responsive UI duytrung.tcu@gmail.com Minh họa: Unresponsive UI • Giao diện người dùng đáp ứng kém • Chương trình đếm: - Đếm từ 1 đến 100.000.000, hiển thị số đếm lên JTextField - chạy đếm khi ấn “Start”, dừng đếm khi ấn “Stop”. Các handler cho hai nút xử lý thông qua 1 cờ tên là stopFlag kiểu Boolean: khởi tạo là false, đặt true khi ấn “Stop”, false khi ấn “Start” duytrung.tcu@gmail.com Minh họa: Unresponsive UI duytrung.tcu@gmail.com btnStart.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { stopFlag = false; for(int i=0; i<10000000;++i) { if(stopFlag) break; tfCount.setText(count + ""); ++count; } } }); btnStop.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent evt) { stop = true; // set the stop flag } }); không thay đổi giá trị?? Tạo thread • Trong Java, thread là đối tượng • Tạo thread mới có thể sử dụng 2 cơ chế sau: duytrung.tcu@gmail.com class interface extends implements 1 2 Runnable (java.lang.Runnable) • Là interface mà các lớp có đặc tính thực thi được bởi các luồng cần kế nhiệm (implements) • Tạo ra một khuôn mẫu chung cho các đối tượng chạy đồng thời • Các lớp kế nhiệm từ Runnable: AsyncBoxView.ChildState, ForkJoinWorkerThread, FutureTask, RenderableImageProducer, SwingWorker, Thread, TimerTask • Phương thức kế nhiệm duy nhất: public void run(); logic thực hiện của đối tượng kế nhiệm sẽ đặt trong phương thức này duytrung.tcu@gmail.com Lớp Thread (java.lang.Thread) • Kế nhiệm từ Runnable • Các hàm khởi tạo chính: public Thread(); public Thread(String threadName); public Thread(Runnable target); public Thread(Runnable target, String threadName); Hai hàm đầu được sử dụng khi tạo thread theo cơ chế kế thừa lớp Thread Hai hàm sau được sử dụng khi tạo thread bằng một đối tượng kế nhiệm Runnable duytrung.tcu@gmail.com Tạo thead: với Thread 1. Tạo một lớp kế thừa Thread và override phương thức run() 2. Tạo một đối tượng từ lớp vừa tạo 3. Chạy thread khi cần bằng phương thức start() duytrung.tcu@gmail.com class MyThread extends Thread{ public void run(){ // logic thực thi thread tại đây ... } } MyThread thr1 = new MyThread() thr1.start(); Tạo thread: với Runnable • Runnable là một interface có phương thức duy nhất là run() 1. Tạo một lớp kế nhiệm Runnable và cung cấp thân hàm cho phương thức run() duytrung.tcu@gmail.com public interface Runnable { void run(); } public class MyRunnable implements Runnable { public void run() { // logic thực thi thread tại đây . . . } } Tạo thread: với Runnable 2. Tạo ra một đối tượng từ lớp vừa tạo 3. Khởi tạo một đối tượng Thread và truyền vào đối tượng kiểu Runnable ở trên 4. Gọi đến phương thức start để bắt đầu thực hiện thread duytrung.tcu@gmail.com Runnable r = new MyRunnable(); t.start(); Thread t = new Thread(r); Demo 1 duytrung.tcu@gmail.com class MyThread extends Thread { private String name; public MyThread(String name) { this.name = name; } @Override public void run() { for(int i = 1; i <= 5; i++) { System.out.println(name+ ":" + i); yield(); } } } Demo 1 duytrung.tcu@gmail.com public class Demo1 { public static void main(String[] args) { Thread[] threads = { new MyThread("Thread 1"), new MyThread("Thread 2"), new MyThread("Thread 3") }; for(Thread t : threads) { t.start(); } } } run: Thread 1:1 Thread 2:1 Thread 3:1 Thread 2:2 Thread 1:2 Thread 2:3 Thread 3:2 Thread 2:4 Thread 1:3 Thread 2:5 Thread 3:3 Thread 1:4 Thread 3:4 Thread 1:5 Thread 3:5 BUILD SUCCESSFUL (total time: 0 seconds) * Không đoán trước được kết quả hiển thị, ta không kiểm soát được hoàn toàn trình tự thực hiện các thread Lớp Thread: Các phương thức Tên phương thức Giải thích public void start() Bắt đầu chạy thread, JRE sẽ gọi đến phương thức run() của lớp, các thread đang chạy vẫn tiếp tục public void run() Chuỗi các lệnh thực thi khi chạy thread, khi run() hoàn thành, thread chấm dứt public static sleep(long milisecs) Đình chỉ thread hiện tại và nhường điều khiển cho thread khác trong khoảng thời gian tính bằng mili-giây (cộng nano-giây). Cho phép thread hoạt động trở lại sớm hơn khoảng thời gian “ngủ” dự kiến thông qua phương thức interrupt. public static sleep(long millisecs, int nanosecs) public void interrupt() public static void yield() Gợi ý cho trình xếp lịch (scheduler) rằng thread hiện tại có thể nhường quyền điều khiển cho thread khác trong lịch chạy, tuy vậy trình xếp lịch có thể bỏ qua gợi ý này public boolean isAlive() Trả về false nếu thread chưa chạy, hoặc đã “chết” và ngược lại public void setPriority(int p) Đặt mức ưu tiên cho thread duytrung.tcu@gmail.com Vòng đời của một thread • Khi khởi tạo, thread ở trạng thái “NEW” • Ở trạng thái này , thread mới chỉ là một đối tượng trong bộ nhớ heap, chưa được cấp tài nguyên gì duytrung.tcu@gmail.com Vòng đời của một thread • Phương thức start() được gọi, thread chuyển sang trạng thái “RUNNABLE” • Thread được cấp tài nguyên cần thiết, được xếp lịch chạy, và gọi phương thức run() duytrung.tcu@gmail.com Vòng đời của một thread Thread rơi vào trạng thái “not RUNNABLE” trong các tình huống sau: • Gọi sleep() • Gọi wait() để chờ một số điều kiện được đáp ứng rồi mới thực hiện tiếp • Bị “blocked” để chờ một thao tác vào /ra thực hiện xong duytrung.tcu@gmail.com Vòng đời của một thread Từ “not RUNNABLE”, thread trở lại “RUNNABLE” trong các trường hợp: • Thread “ngủ” được báo thức khi hết thời gian hoặc gọi interrupt() • Thread đang chờ do gọi wait() thì notify() hoặc notifyAll() được gọi thông báo các điều kiện cần thiết đã xong và có thể chạy tiếp • Thao tác vào/ra được thực hiện xong, thread được “unblocked” duytrung.tcu@gmail.com Vòng đời của một thread • Thread kết thúc hay ở trạng thái “TERMINATED” khi phương thức run() chạy xong và kết thúc • isAlive() kiểm tra xem thread còn sống hay không duytrung.tcu@gmail.com isAlive() = true isAlive() = false Vòng đời của một thread Phương thức getState() trả về trạng thái hiện tại của thread, có kiểu enum trong Thread.State, nhận một trong các giá trị sau  NEW  RUNNABLE  WAITING  BLOCKED  TIMED_WAITING  TERMINATED duytrung.tcu@gmail.com Mức ưu tiên và xếp lịch cho thread • JVM xếp lịch chạy cho các thread dựa trên mức ưu tiên • Mỗi thread được gán một mức ưu tiên là một số nguyên trong khoảng từ Thread.MIN_PRIORITY đến Thread.MAX_PRIORITY, Thread.NORM_PRIORITY là mức ưu tiên mặc định bằng 5 • Khi thread được tạo, nó kế thừa mức ưu tiên từ thread cha • Đặt mức ưu tiên cho thread bằng phương thức public void setPriority(int priority); trong đó, int priority phụ thuộc vào JVM, có thể trong khoảng từ 1 đến 10 duytrung.tcu@gmail.com Mức ưu tiên và xếp lịch cho thread • Mức ưu tiên càng cao, càng được JVM ưu tiên chạy trước • Với các thread cùng mức ưu tiên cao nhất, JVM xếp lịch cho chúng theo thuật toán Round Robin • Xét ưu tiên, nếu một thread có mức ưu tiên cao hơn trở nên RUNNABLE, thread đang chạy có mức ưu tiên thấp hơn ngay lập tức phải nhường điều khiển cho nó • Nếu nhiều thread đang RUNNABLE và có cùng mức ưu tiên, một thread có thể chiếm điều khiển cho đến khi chạy xong (tham ăn - starvation). Có thể sử dụng sleep() hoặc yield() để phân bổ điều khiển cho các thread khác nữa duytrung.tcu@gmail.com Mức ưu tiên và xếp lịch cho thread Tóm lại, một thread sẽ duy trì chạy cho tới khi:  Một thread mức ưu tiên cao hơn trở nên RUNNABLE  Chủ động nhường điều khiển cho thread khác thông qua các phương thức wait(), yield() và sleep()  Thread kết thúc, cụ thể là run() kết thúc  Trên các hệ điều hành có chia khe thời gian (time slicing), thread sẽ dừng khi dùng hết định mức CPU dành cho nó • Lưu ý quan trọng: xếp lịch ưu tiên cho thread phụ vào JVM, JVM thông qua hệ điều hành để thực hiện đa luồng, không phải lúc nào JVM cũng đảm bảo thread có mức ưu tiên cao nhất được chạy trước, chẳng hạn thread có ưu tiên thấp hơn có thể được chạy để ngăn starvation. Do đó, đừng quá tin tưởng vào mức ưu tiên khi thiết kế thuật toán duytrung.tcu@gmail.com Nhóm thread – ThreadGroup • Một số trường hợp đòi hỏi gom các thread có chức năng tương tự nhau thành nhóm để tiện sử dụng  Lấy ví dụ với một trình duyệt web, nếu nhiều thread đều đang thực hiện lấy một bức ảnh trên internet về thì người dùng bấm Stop để ngừng quá trình tải trang web lại; lúc này sẽ rất tiện lợi và an toàn nếu như có thể dừng tất cả các thread đang tải ảnh về cùng một lúc • Xây dựng một ThreadGroup cho phép làm việc với một nhóm các thread String groupName = “Loading Image Group”; // Tên nhóm phải là duy nhất ThreadGroup g = new ThreadGroup(groupName); duytrung.tcu@gmail.com Nhóm thread – ThreadGroup • Đưa thread vào threadGroup thông qua hàm khởi tạo: Thread t = new Thread(g, threadName); • Phương thức activeCount() trả về số thread còn có thể chạy được if(g.activeCount == 0){ // Tất cả các thread đều đã kết thúc} • Để ngắt tất cả các thread trong một nhóm, gọi đến interrupt() cho cả nhóm g.interrupt(); duytrung.tcu@gmail.com Đồng bộ thread (Synchronization) • Trong các ứng dụng đa luồng, một tình huống phổ biến là hai thread trở lên cần tương tác với cùng đối tượng • Điều gì xảy ra nếu các thread này đều thay đổi đối tượng theo những chiều hướng khác nhau? • Đồng bộ thread rất quan trọng, ngăn chặn tình trạng các thread “giẫm chân lên nhau” duytrung.tcu@gmail.com Minh họa khi không đồng bộ thread Giả thiết ta xây dựng một ngân hàng, quản lý 100 tài khoản, mỗi tài khoản ban đầu có 1000$. Các tài khoản chuyển một số tiền ngẫu nhiên đến một tài khoản ngẫu nhiên trong nội bộ ngân hàng. duytrung.tcu@gmail.com 100.000 Minh họa khi không đồng bộ thread • Xây dựng lớp Bank:  double[] accounts: mảng chứa số tiền của các tài khoản • Hàm khởi tạo và các phương thức:  public Bank(int n, double initialBalance) : n tài khoản, và số tiền ban đầu trong mỗi tài khoản  public void transfer(int from, int to, double amount): phương thức chuyển số tiền amount từ tài khoản from, đến tài khoản to  public double getTotalBalance(): phương thức trả về số tiền đang có trong toàn ngân hàng, bằng tổng số tiền của tất cả các tài khoản duytrung.tcu@gmail.com Minh họa khi không đồng bộ thread • Xây dựng mỗi tài khoản là một thread, mỗi thread liên tục chuyển tiền từ tài khoản hiện tại sang tài khoản khác bằng phương thức transfer() • In ra thông tin mỗi giao dịch và tính tổng số tiền trong toàn ngân hàng bằng phương thức getTotalBalance(). Kết quả in ra có dạng như sau: duytrung.tcu@gmail.com Minh họa khi không đồng bộ thread duytrung.tcu@gmail.com accounts[to] += amount 1. Tải accounts[to] vào thành ghi 2. Cộng với amount 3. Trả kết quả về với accounts[to] +500$ +900$ đúng phải là 6400, mất 900$! Thread safe • Một đoạn chương trình được gọi là thread safe – an toàn với đa luồng – nếu nó hoạt động đúng khi được thực thi đồng thời bởi nhiều thread • Đáp ứng được nhiều thread sử dụng một dữ liệu chia sẻ: mảng account trong ví dụ ngân hàng chẳng hạn • “Đồng thời” xét trên khía cạnh hiệu quả thu được, còn mỗi thời điểm chỉ có một thread sử dụng dữ liệu chia sẻ • Rõ ràng phương thức transfer() không thread safe! duytrung.tcu@gmail.com • Vấn đề: phương thức transfer() có thể bị cắt ngang bởi một thread khác, hoặc thread hiện tại chưa thực hiện xong thì đã hết tài nguyên (khe thời gian chẳng hạn) • Giải quyết: phải đảm bảo hoàn thành phương thức rồi mới nhường điều khiển cho thread khác duytrung.tcu@gmail.com Đồng bộ thread (Synchronization) Đồng bộ thread (Synchronization) 2 cơ chế chính để bảo vệ một khu vực lệnh khỏi các truy cập đồng thời: 1. Sử dụng Lock, cụ thể là lớp ReentrantLock, xuất hiện từ JDK 5.0 2. Sử dụng từ khóa synchronized trước JDK 5.0 duytrung.tcu@gmail.com Đồng bộ thread (Synchronization) 2 cơ chế chính để bảo vệ một khu vực lệnh khỏi các truy cập đồng thời: 1. Sử dụng Lock, cụ thể là lớp ReentrantLock, xuất hiện từ JDK 5.0 2. Sử dụng từ khóa synchronized trước JDK 5.0 duytrung.tcu@gmail.com Lớp ReentrantLock (java.util.concurrent.locks) • Dàn cảnh bảo vệ đoạn lệnh sử dụng ReentrantLock như sau: • Khi có một thread “bấm khóa” đối tượng myLock, không thread nào khác có thể xâm nhập vào đoạn lệnh chính • Khi thread khác gọi đến phương thức lock(), thread này sẽ rơi vào trạng thái BLOCKED, cho đến khi thread kia “mở khóa” myLock duytrung.tcu@gmail.com myLock.lock(); // a ReentrantLock object try{ bank.transfer(from, to, amount); } finally { myLock.unlock(); // make sure the lock is unlocked even if // an exception is thrown } Vấn đề với kiểm tra điều kiện • Trong ví dụ ngân hàng, ta mong muốn số dư của tài khoản nguồn phải không nhỏ hơn lượng tiền cần chuyển: • Kịch bản sau hoàn toàn có thể xảy ra: thread mới kiểm tra điều kiện xong, kết quả là hợp lệ, chưa chuyển tiền thì mất quyền điều khiển: • Đến khi thread chạy lại, số dư tài khoản này lại nhỏ hơn số tiền muốn chuyển, do đó ta cần đảm bảo rằng thread phải không bị gián đoạn trong quá trình trong quá trình kiểm tra điều kiện và chuyển tiền duytrung.tcu@gmail.com if(bank.getBalance(from) >= amount) bank.transfer(from, to, amount); if(bank.getBalance(from) >= amount) // Mới kiểm tra điều kiện xong thì đến phiên thread khác bank.transfer(from, to, amount); Vấn đề với kiểm tra điều kiện • Cách giải quyết: bảo vệ toàn bộ đoạn lệnh trong transfer() như sau: duytrung.tcu@gmail.com public void transfer(int from, int to, double amount){ bankLock.lock(); try{ while(accounts[from] < amount){ // chờ tài khoản khác chuyển tiền vào cho đến khi // số dư là hợp lệ ... } // chuyển tiền ... } finally{ bankLock.unlock(); } } Không khả thi do thread hiện tại đã chiếm quyền điều khiển cho đến khi đối tượng bankLock được unlock! Biến điều kiện – đối tượng Condition • Condition (java.util.concurrent.locks) là một interface, đóng vai trò như một phương tiện để dừng thread lại, cho đến khi được một thread khác thông báo điều kiện đã đảm bảo để chạy tiếp • Một đối tượng Condition luôn sinh từ một “khóa” cụ thể. Để sinh một Condition, gọi phương thức newCondition() từ đối tượng “khóa” • Một “khóa” do đó có thể gắn với một hoặc nhiều đối tượng Condition • Đặt tên Condition sao cho mô tả được điều kiện mà nó đại diện duytrung.tcu@gmail.com Biến điều kiện – đối tượng Condition Tên phương thức Mô tả void await() Đưa thread hiện tại về tình trạng chờ, cho đến khi được thread khác báo hiệu (signal) hoặc bị ngắt (interrupt) boolean await(long time, TimeUnit unit) Tương tự như await(), thêm khoảng thời gian tối đa cho thread ở tình trạng chờ long awaitNanos(long nanosTimeout) Tương tự như await(), thêm khoảng thời gian tối đa cho thread ở tình trạng chờ tính bằng nano-giây void awaitUninterruptibly() Đưa thread về tình trạng chờ cho đến khi được thread khác báo hiệu boolean awaitUntil(Date deadline) Đưa thread về tình trạng chờ đến hết thời hạn deadline void signal() Đánh thức một thread đang chờ void signalAll() Đánh thức tất cả các thread đang chờ duytrung.tcu@gmail.com Biến điều kiện – đối tượng Condition • Trở lại ví dụ ngân hàng, ta sinh ra một đối tượng Condition để đặc trưng cho điều kiện “số dư tài khoản hợp lệ” • Khi khởi tạo đối tượng Bank, khởi tạo đối tượng Condition: • Khi kiểm tra thấy số dư tài khoản không hợp lệ, ta dừng thread để chờ đến khi đủ số dư bằng phương thức await() duytrung.tcu@gmail.com private Condition sufficientFunds; sufficientFunds = bankLock.newCondition(); while(accounts[from] < amount){ sufficientFunds.await(); ... } Biến điều kiện – đối tượng Condition • Thread hiện tại sẽ rơi vào trạng thái BLOCKED, đưa vào trong danh sách đợi (waitset), và nhả “khóa” cho thread khác • Trạng thái BLOCKED này khác với ngữ cảnh khi chờ khóa: thread tiếp tục BLOCKED kể cả khi “khóa” sẵn sàng trở lại, nó chỉ UNBLOCKED khi một thread khác gọi đến signalAll() của cùng đối tượng Condition • Lúc này thread trở lại RUNNABLE, được xếp lịch chạy, và sẵn sàng nhận khóa khi có thể duytrung.tcu@gmail.com sufficientFunds.signalAll(); Biến điều kiện – đối tượng Condition • Khi nhận được “khóa”, thread tiếp tục tại vị trí cuối cùng khi nó rời đi: trở lại từ await() • Tại thời điểm này, rõ ràng thread nên kiểm tra lại điều kiện, bởi dễ hiểu điều kiện được đánh giá là đúng chỉ tại thời điểm gọi signalAll(), còn hiện tại thì chưa biết • Do vậy, một kinh nghiệm là nên gọi await() từ đối tượng điều kiện trong một vòng lặp duytrung.tcu@gmail.com while(accounts[from] < amount){ sufficientFunds.await(); ... } Deadlock • Deadlock là hiện tượng hai hoặc nhiều thread chờ nhau nhả khóa và do đó bị “tắc” mãi mãi duytrung.tcu@gmail.com Deadlock • Khi thread gọi await(), “số phận” của nó phụ thuộc vào các thread còn lại: nếu không thread nào gọi signalAll(), nó sẽ vĩnh viễn không chạy trở lại nữa→ deadlock • Khi các thread đều đang block, còn lại thread cuối cùng gọi await() mà không unblock bất kỳ thread nào, do đó tất cả đều BLOCKED, chương trình “treo”!!→ deadlock • Kinh nghiệm: gọi signalAll() mỗi khi trạng thái của đối tượng thay đổi theo chiều hướng có lợi cho các thread đang chờ duytrung.tcu@gmail.com Deadlock • Ở ví dụ ngân hàng, mỗi khi số dư tài khoản được cập nhật, các thread đang chờ cần được trao cơ hội để kiểm tra xem số dư tài khoản của mình đã hợp lệ chưa, bằng cách gọi signalAll() duytrung.tcu@gmail.com public void transfer(int from, int to, double amount){ bankLock.lock(); try{ while(accounts[from] < amount){ sufficientFunds.await(); // chuyển tiền sufficientFunds.signalAll(); } finally{ bankLock.unlock(); } } Deadlock • Phương thức signal() chỉ đánh thức một thread duy nhất, được chọn ngẫu nhiên, trong danh sách đợi • signal() rõ ràng có hiệu năng tốt hơn signalAll(), tuy vậy tiềm ẩn một rủi ro: nếu như thread được đánh thức chạy tiếp song vẫn chưa đạt điều kiện, nó sẽ về trạng thái BLOCKED để chờ tiếp. Nếu như không có thread nào khác gọi đến signal() nữa, chương trình “treo”→ deadlock duytrung.tcu@gmail.com Tổng kết về Lock và Condition • Một khóa bảo vệ một khu vực code, chỉ cho phép một thread được thực thi code tại mỗi thời điểm • Một khóa chịu trách nhiệm điều hành các thread đang muốn thực thi khu vực code được bảo vệ • Một khóa có thể liên kết với một hoặc nhiều biến điều kiện Condition • Mỗi biến điều kiện chịu trách nhiệm điều hành các thread đã xâm nhập vào khu vực code bảo vệ song không thể chạy tiếp do điều kiện chưa đáp ứng duytrung.tcu@gmail.com Đồng bộ thread (Synchronization) 2 cơ chế chính để bảo vệ một khu vực lệnh khỏi các truy cập đồng thời: 1. Sử dụng Lock, cụ thể là lớp ReentrantLock, xuất hiện từ JDK 5.0 2. Sử dụng từ khóa synchronized trước JDK 5.0 duytrung.tcu@gmail.com Từ khóa synchronized • Trước Lock và Condition, Java sử dụng một cơ chế tương tranh khác • Mỗi đối tượng Java đều có một “khóa ẩn” (implicit lock) • Nếu một phương thức được khai bao với từ khóa synchronized, khóa của đối tượng sẽ bảo vệ cho toàn bộ phương thức • Do vậy, để gọi được phương thức, thread phải giành được khóa của đối tượng chứa phương thức duytrung.tcu@gmail.com Cơ chế Lock và cơ chế synchronized • “Khóa ẩn” của đối tượng chỉ có một “điều kiện ẩn” gắn kèm duytrung.tcu@gmail.com public synchronized void method() { // method body } public void method() { implicitLock.lock(); try{ // method body } finally{ implicitLock.unlock(); } } wait() ↔ implicitCondition.await() notify() ↔ implicitCondition.signal() notifyAll() ↔ implicitCondition.signalAll() Sử dụng synchronized cho một khối lệnh • Khai báo một đối tượng Object chỉ để tận dụng “khóa ẩn” của nó duytrung.tcu@gmail.com class Bank{ private Object lock = new Object(); private double accounts[]; public void transfer(int from, int to, double amount){ synchronized(lock){ accounts[from] -= amount; accounts[to] += amount; } ... } ... Từ khóa volatile • Đôi khi, việc đồng bộ thread sử dụng lock hay synchronized sẽ lãng phí khi ta chỉ đọc ghi đến một, hai thuộc tính của đối tượng • Từ khóa volatile cung cấp một cơ chế không cần khóa để đồng bộ việc truy cập đến một thuộc tính của đối tượng Ví dụ một đối tượng có một cờ boolean tên done có thể được được set bằng thread này, get bằng thread khác: duytrung.tcu@gmail.com private boolean done; public synchronized boolean isDone() { return done; } private volatile boolean done; public boolean isDone() { return done; } Tổng kết về truy cập đồng thời Truy cập đồng thời đến một thuộc tính là an toàn trong các trường hợp sau: • Thuộc tính là volatile • Thuộc tính là final, và truy cập diễn ra sau khi nó đã được khởi tạo • Truy cập đến thuộc tính được bảo vệ bởi một khóa duytrung.tcu@gmail.com Thread trên Swing Một ứng dụng Swing chạy trên nhiều thread, chia làm 3 loại: 1. Main thread, là thread chạy phương thức main(), bắt đầu và kết thúc GUI 2. Event-dispatching thread (EDT) 3. Một số thread nền duytrung.tcu@gmail.com Thread trên Swing • Mọi thao tác xử lý sự kiện, vẽ và hiển thị đều thực hiện ở EDT, nhằm đảm bảo:  Các sự kiện được xử lý lần lượt, kết thúc cái này mới đến cái khác  Quá trình vẽ không bị ngắt bởi các sự kiện • Nếu EDT bị chiếm bởi bởi một tác vụ đòi hỏi khối lượng tính toàn lớn, thì giao diện sẽ “đóng băng”! • Kinh nghiệm cho thấy những tác vụ nào yêu cầu thời gian thực hiện từ 30 mili-giây trở lên thì không nên chạy trên EDT • Code tương tác với các component nên chạy trên EDT, vì nhiều component không thread safe! duytrung.tcu@gmail.com Thread trên Swing Tóm lại: • Các tác vụ tốn thời gian hoặc tác vụ IO không nên chạy trên EDT, nếu không sẽ ảnh hưởng đến tính đáp ứng của giao diện • Các component của Swing chỉ nên được sử dụng trong EDT để đạt được thread safe duytrung.tcu@gmail.com invokeLater() và invokeAndWait() • javax.swing.SwingUtilities • invokeLater(Runnable) và invokeAndWait(Runnable) đặt một tác vụ Runnable vào chạy trong EDT • Để ngăn chặn các vấn đề xảy ra giữa main thread và EDT, sử dụng invokeLater(Runnable) để tạo các component trong EDT, thay vì main thread • Gọi invokeLater() trong bất cứ thread nào để yêu EDT chạy đoạn code trong phương thức run() của đối tượng Runnable • Giống với java.awt.EventQueue.invokeLater() duytrung.tcu@gmail.com invokeLater() và invokeAndWait() • invokeAndWait() chờ EDT chạy xong đoạn code cụ thể mới trả về, hay được sử dụng trong init() của JApplet duytrung.tcu@gmail.com /** The entry main() method */ public static void main(String args[]) { // Run the GUI codes on the event-dispatching thread for thread-safety SwingUtilities.invokeLater(new Runnable() { @Override public void run() { JFrame frame = new JFrame("My Swing Application"); frame.setContentPane(new MyMainPanel()); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.pack(); frame.setLocationRelativeTo(null); // center on screen frame.setVisible(true); // show it } }); } SwingWorker • Là lớp trừu tượng, tạo kết nối giữa EDT với một số thread chạy nền • Sử dụng để xếp các tác vụ tính toán lớn vào thread chạy nền và trả kết quả trung gian hoặc kết quả cuối cùng về cho EDT • Khai báo lớp của SwingWorker như sau: public abstract class SwingWorker implements RunnableFuture trong đó: T chỉ kiểu kết quả trả về của phương thức doInBackground() và get() V chỉ kiểu kết quả trả về của các phương thức publish() và process() RunnableFuture là kết hợp của 2 interface: Runnable và Future. Runnable có run(), Future có get(), cancel(), isDone() và isCancelled() duytrung.tcu@gmail.com SwingWorker duytrung.tcu@gmail.com Tên phương thức Mô tả protected T doInBackground() throws Exception Thực thi tác vụ nào đó trong thread chạy nền protected void done() Làm gì trên EDT sau khi doInBackground() chạy xong public final T get() throws InterruptedException, ExecutionException Chờ doInBackground() chạy xong và lấy kết quả Gọi get() trong EDT sẽ dừng mọi sự kiện lại, kể cả vẽ lại, cho đến khi SwingWorker chạy xong public final void execute() Bắt đầu thực hiện tác vụ trong SwingWorker public final boolean cancel(boolean mayInterruptIfRunning) Cố gắng hủy bỏ tác vụ đang được SwingWorker thực hiện public final boolean isDone() Trả về true nếu tác vụ đã được hoàn thành public final boolean isCancelled() Trả về true nếu tác vụ đã bị hủy trước khi hoàn thành