Bài Thực Hành Số 1 – newSingleThreadExecutors

Như đã nói trên kia, phương thức newSingleThreadExecutors của Executors giúp tạo ra một Thread Pool mà chỉ có duy nhất 1 Thread được thực thi một lần.

Để kiểm chứng, chúng ta cùng xây dựng Thread Pool này. Nhưng trước hết, mình muốn các bạn xây dựng một Runnable để chúng ta có thể truyền chúng vào trong Thread Pool mà chúng ta sẽ xây dựng ở bước kế tiếp sau. Runnable này mình đặt tên là MyRunnable nhé.

public class MyRunnable implements Runnable {
 
    // Tên của Runnable, giúp chúng ta phân biệt Runnable nào đang thực thi trong Thread Pool
    private String name;
     
    public MyRunnable(String name) {
        // Khởi tạo Runnable với biến name truyền vào
        this.name = name;
    }
     
    @Override
    public void run() {
        System.out.println(name + " đang thực thi...");
 
        // Giả lập thời gian chạy của Runnable mất 2 giây
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
         
        System.out.println(name + " kết thúc.");
    }
 
}

Trên đây là một Runnable bình thường thôi. Tại sao chúng ta lại phải sử dụng Runnable? Vì Thread Pool chỉ nhận các Runnable truyền vào (và Callable nữa mà bạn sẽ làm quen sau, nhưng Callable cũng giống Runnable mà thôi). Bạn nên nhớ là các Runnable khi chưa gọi phương thức start() thì vẫn chưa được hệ thống thực thi thành các Thread. Bạn có thể xem lại kiến thức này ở bài học về Thread này. Do đó việc chúng ta truyền các Runnable vào Thread Pool là để cho Thread Pool sắp xếp chúng vào hàng đợi. Đến khi quyết định thực thi Runnable nào, các Thread Pool sẽ tiến hành start() Runnable đó.

Tiếp theo sau là code ở phương thức main.

public static void main(String[] args) {        
    // Khai báo một Thread Pool thông qua newSingleThreadExecutor() của Executors
    ExecutorService executorService = Executors.newSingleThreadExecutor();
         
    // Khai báo 10 Runnable, và "quăng" chúng vào Thread Pool vừa khai báo
    for (int i = 1; i <= 10; i++) {
        MyRunnable myRunnable = new MyRunnable("Runnable " + i);
        executorService.execute(myRunnable);
    }
         
    // Phương thức này sẽ được nói sau ở ExecutorService
    executorService.shutdown();
}

Bạn có thể thấy, dòng đầu tiên của code trên khai báo một Thread Pool thông qua phương thức Executors.newSingleThreadExecutor(). Phương thức này của Executors giúp tạo một Thread Pool với chỉ duy nhất một Thread được thực thi. Thread Pool này được quản lý thông qua biến executorService, đây chính là lớp ExecutorService mà chúng ta sẽ tìm hiểu sau. Bạn chỉ cần biết thêm là phương thức executorService.execute(myRunnable) giúp lần lượt đưa các Runnable được khởi tạo vào trong Thread Pool và lần lượt thực thi sau đó.

Đến đây bạn có thể thực thi chương trình để xem, bạn có thể thấy cứ mỗi 2 giây, chỉ có 1 Thread được chạy và in ra console mà thôi. Hình dưới là kết quả ở console của máy mình.

Bài Thực Hành Số 2 – newFixedThreadPool

Thông qua bài thực hành trên, bạn đã hiểu cách làm việc với Thread Pool rồi. Bài thực hành số 2 này mình không nói nhiều. Bạn tự code lại theo khai báo mới của Thread Pool (như tô sáng ở code dưới) rồi trải nghiệm nhé. Lưu ý là chúng ta dùng lại MyRunnable và không thay đổi gì cả trong code của lớp này để cùng so sánh xem Thread Pool mới này sẽ cho ra kết quả khác như thế nào ở console.

public static void main(String[] args) {        
    // Khai báo một Thread Pool thông qua newFixedThreadPool(5) của Executors.
    // Thread Pool này cho phép thực thi cùng một lúc 5 Thread
    ExecutorService executorService = Executors.newFixedThreadPool(5);
         
    // Khai báo 10 Runnable, và "quăng" chúng vào Thread Pool vừa khai báo
    for (int i = 1; i <= 10; i++) {
        MyRunnable myRunnable = new MyRunnable("Runnable " + i);
        executorService.execute(myRunnable);
    }
         
    // Phương thức này sẽ được nói sau ở ExecutorService
    executorService.shutdown();
}

Bài Thực Hành Số 3 – newCachedThreadPool

Cũng tương tự, bạn hãy thử dùng newCachedThreadPool để tạo một Thread Pool xem. Với cách này hệ thống sẽ thực thi hết các Thread trong phương thức main của chúng ta.

public static void main(String[] args) {        
    // Khai báo một Thread Pool thông qua newCachedThreadPool của Executors.
    ExecutorService executorService = Executors.newCachedThreadPool();
         
    // Khai báo 10 Runnable, và "quăng" chúng vào Thread Pool vừa khai báo
    for (int i = 1; i <= 10; i++) {
        MyRunnable myRunnable = new MyRunnable("Runnable " + i);
        executorService.execute(myRunnable);
    }
         
    // Phương thức này sẽ được nói sau ở ExecutorService
    executorService.shutdown();
}

Bài Thực Hành Số 4 – submit(Runnable)

Do bài thực hành này cũng dùng đến Runnable, nên mình sẽ vẫn dùng lại MyRunnable đã được xây dựng từ các bài thực hành trước. Bạn chú ý một chút cách gọi submit() để trả về danh sách các Future như sau.

public static void main(String[] args) throws InterruptedException {        
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    List<Future> listFuture = new ArrayList<Future>(); // Khởi tạo danh sách các Future
         
    for (int i = 1; i <= 10; i++) {
        MyRunnable myRunnable = new MyRunnable("Runnable " + i);
        // Bước này chúng ta dùng submit() thay vì execute()
        Future future = executorService.submit(myRunnable);
        listFuture.add(future); // Từng Future sẽ quản lý một Runnable
    }
     
    for (Future future : listFuture) {
        try {
            // Khi Thread nào kết thúc, get() của Future tương ứng sẽ trả về null
            System.out.println(future.get());
        } catch (ExecutionException | InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
         
    // Phương thức này đã nói ở trên đây rồi
    executorService.shutdown();
}

Bạn thấy rằng kết quả sau đây có in ra các dòng “null”. Chúng là các kết quả của các lời gọi future.get(). Và vì phương thức submit() này của ExecutorService giúp trả về các kết quả theo kiểu đồng bộ, tức là khi Thread kết thúc thì null mới được trả về thông qua future.get(), nên dù cho bạn đã gọi chúng rất sớm, chúng vẫn sẽ chỉ in ra null khi nào Thread kết thúc mà thôi.

Bài Thực Hành Số 5 – submit(Callable)

Bài thực hành này chúng ta cũng sẽ làm quen với Callable. Cơ bản thì Callable cũng khá giống với Runnable, nó cũng giúp để khởi tạo Thread trong ThreadPool. Nhưng Callable hữu ích hơn Runnable ở chỗ nó cho phép trả về một kết quả mà bạn định nghĩa sẵn. Chúng ta cùng đến với code khai báo một Callable như sau, rồi cùng nhau nói về nó tiếp theo nữa nhé. Callable này mình đặt tên là MyCallable.

public class MyCallable implements Callable<String> {
 
    // Tên của Callable, giúp chúng ta phân biệt Runnable nào đang thực thi trong
    // Thread Pool
    private String name;
 
    public MyCallable(String name) {
        // Khởi tạo Callable với biến name truyền vào
        this.name = name;
    }
 
    @Override
    public String call() throws Exception {
        System.out.println(name + " đang thực thi...");
         
        // Giả lập thời gian chạy của Callable mất 2 giây
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // Trả kết quả về là một kiểu String
        return name;
    }
}

Dòng đầu tiên bạn thấy có khai báo lớp MyCallable kế thừa từ Callable<String>. Cách viết Callable<String> mình sẽ nói rõ hơn khi nói về kiến thức Generic sau này. Cơ bản bạn có thể hiểu Callable<String> là một Callable với một ràng buộc trong code của bạn phải trả về kiểu dữ liệu là String. Nếu bạn muốn trả về kiểu dữ liệu khác thì cứ thay String bằng kiểu dữ liệu bạn muốn là được.

Tương tự, vì Callable<String> ràng buộc bạn phải trả về kiểu String, nên code bên trong nó bạn phải Override phương thức call() với kiểu trả về là String luôn. Phương thức call() này của Callable thay cho run() bên Runnable, chỉ khác là call() có đòi hỏi kết quả trả về. Lúc này chúng ta trả về biến name luôn và in dòng kết thúc ở bên ngoài nhé.

Với việc khai báo Callable như trên, mình sẽ tiến hành gọi như sau ở phương thức main. Bạn xem.

public static void main(String[] args) throws InterruptedException {        
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    List<Future<String>> listFuture = new ArrayList<Future<String>>(); // Khởi tạo danh sách các Future
         
    for (int i = 1; i <= 10; i++) {
        // Dùng Callable thay cho Runnable
        MyCallable myCallable = new MyCallable("Callable " + i);
             
        Future<String> future = executorService.submit(myCallable);
        listFuture.add(future); // Từng Future sẽ quản lý một Callable
    }
         
    for (Future future : listFuture) {
        try {
            // Khi Thread nào kết thúc, get() của Future tương ứng sẽ trả về kết quả mà Callable return
            System.out.println(future.get() + " kết thúc");
        } catch (ExecutionException | InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
         
    // Phương thức này đã nói ở trên đây rồi
    executorService.shutdown();
}

Có một điều chắc bạn cũng sẽ hơi nhức đầu. Đó là thay vì khai báo List<Future> như bài thực hành trước (bài học về List, ArrayList gì đó, chính là các Collection mình cũng sẽ nói sau), thì bây giờ lại phải khai báo List<Future<String>>. Bạn nên biết rằng, chắc chắn cái đoạn <String> ở khai báo List này có liên quan mật thiết với <String> ở khai báo lớp Callable trên kia rồi, và như đã nói, mình sẽ nói sau ở bài về Generic. Bây giờ khi thực thi chương trình, kết quả không nằm ngoài tiên liệu của chúng ta. Có điều do phương thức future.get() có một độ trễ nhất định, nên việc in ra Callable nào kết thúc không ngay tức thời, nên nhìn vào kết quả console sau, bạn sẽ thấy dường như có nhiều Thread được thêm vào Thread Pool hơn khai báo 5 Thread ban đầu.

Bài Thực Hành Số 6 – invokeAny()

Do bài học đã quá dài, nên mục invokeAny() mình chỉ cho các bạn xem code, và kết quả thực thi chương trình. Ý nghĩa của phương thức này mình đã giải thích trên kia rồi nhé. Có khác một tí là ví dụ này mình không dùng đến MyCallable nữa, mình muốn khai báo các Callable trực tiếp trong vòng for bằng cách dùng đến lớp vô danh cho code được gọn nhẹ.

public static void main(String[] args) throws InterruptedException, ExecutionException {        
    // Khai báo một Thread Pool thông qua newSingleThreadExecutor() của Executors
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    List<Callable<String>> listCallable = new ArrayList<Callable<String>>(); // Khởi tạo danh sách các Callable
         
    for (int i = 1; i <= 5; i++) {
        final int _i = i;
        // Khởi tạo từng Callable
        listCallable.add(new Callable<String>() {
 
            @Override
            public String call() throws Exception {
                // Trả về kết quả ở mỗi Callable
                return "Callable " + _i;
            }
        });
    }
         
    // Callable nào kết thúc ở đây cũng sẽ dừng luôn Thread Pool
    String result = executorService.invokeAny(listCallable);
    System.out.println("Result: " + result);
         
    // Phương thức này đã nói ở trên đây rồi
    executorService.shutdown();
}

Bài Thực Hành Số 7 – invokeAll()

public static void main(String[] args) throws InterruptedException, ExecutionException {        
    // Khai báo một Thread Pool thông qua newSingleThreadExecutor() của Executors
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    List<Callable<String>> listCallable = new ArrayList<Callable<String>>(); // Khởi tạo danh sách các Callable
         
    for (int i = 1; i <= 5; i++) {
        final int _i = i;
        // Khởi tạo từng Callable
        listCallable.add(new Callable<String>() {
 
            @Override
            public String call() throws Exception {
                // Trả về kết quả ở mỗi Callable
                return "Callable " + _i;
            }
        });
    }
         
    // Dùng Future để lấy về danh sách các kết quả trả về từ mỗi Callable
    List<Future<String>> futures = executorService.invokeAll(listCallable);
    for(Future<String> future : futures) {
        System.out.println("Result: " + future.get());  
    }
         
    // Phương thức này đã nói ở trên đây rồi
    executorService.shutdown();
}