Bài Thực Hành Số 1 – Xây Dựng Thread Pool Giống Như newSingleThreadExecutors

Bài này chúng ta cùng xây dựng lại Thread Pool mà ở Bài thực hành số 1 của bài học trước chúng ta đã xây dựng thông qua Executors. Khi đó Thread Pool của chúng ta mỗi lần chỉ có duy nhất một Thread được chạy.

Trước hết, mình xin hiển thị lại lớp MyRunnable, mình lấy lại lớp này từ bài hôm trước, nhưng có thay đổi một chút xíu như sau để các bài thực hành được rõ nghĩa hơn.

• Mình truyền thêm ThreadPoolExecutor vào phương thức khởi tạo luôn, để mỗi lần MyRunnable này được thực thi, chúng ta sẽ in ra số lượng Thread đang chạy và đang chờ trong Pool của chúng ta.
• Mình override lại phương thức toString() để lát nữa đây chúng ta có thể in ra tên của MyRunnable này từ main().

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;
    // ThreadPoolExecutor để in ra số lượng Thread đang chạy và đang chờ trong Pool
    private ThreadPoolExecutor executor;

    public MyRunnable(String name, ThreadPoolExecutor executor) {
        this.name = name;
        this.executor = executor;
    }

    @Override
    public void run() {
        // In tên Thread, kèm số lượng Thread đang chạy và đang chờ trong Pool
        System.out.println(name + " đang thực thi... (số thread chạy: " + executor.getPoolSize() + ", số thread chờ: " + executor.getQueue().size() + ")");

        // 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();
        }

        // In trạng thái kết thúc
        System.out.println(name + " kết thúc.");
    }

    @Override
    public String toString() {
        return name;
    }
}

Và đây là cách dùng ThreadPoolExecutor ở phương thức main().

public static void main(String args[]) {
    int corePoolSize = 1;
    int maximumPoolSize = 1;
    long keepAliveTime = 0L;
    TimeUnit unit = TimeUnit.MILLISECONDS;
    LinkedBlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bạn có thể so sánh nhanh với code của bài hôm trước. Hôm nay chúng ta “thủ công hóa” với một đống tham số dùng cho phương thức khởi tạo của ThreadPoolExecutor (nếu bạn biết cách vào xem phương thức newSingleThreadExecutors() được xây dựng sẵn của bài hôm trước trên Eclipse hay InteliJ thì thấy với khai báo tham số hôm nay là tương tự nhau). Chắc các bạn cũng đoán được nhưng mình cũng xin giải nghĩa một chút cách sử dụng các tham số.

• corePoolSize chúng ta khai báo là 1, điều này khiến cho Thread Pool chỉ chứa tối đa 1 Thread như bài hôm trước.
• maximumPoolSize cũng là 1, chúng ta không muốn Thread Pool đưa thêm bất kỳ Thread nào vào nữa, chỉ một mà thôi.
• keepAliveTime khi này được chỉ định là 0 (mili giây), vì với ví dụ này tham số này không có tác dụng gì cả vì mỗi corePoolSize và maximumPoolSize là như nhau, không có Thread nào start khi vượt quá corePoolSize cả.
• workQueue sẽ chứa trong một LinkedBlockingQueue. Mình sẽ nói cụ thể về các loại Queue sau. Bạn chỉ cần biết với việc dùng LinkedBlockingQueue thì Queue này giúp chứa không giới hạn số lượng các Runnable đợi được thực thi khi mà corePoolSize đã đầy.

Có thể bạn chưa hiểu lắm các thông số. Nhưng cứ thực thi chương trình đi nhé, chúng ta sẽ làm rõ dần các thông số này ở các bài thực hành tiếp theo bên dưới. Và đây là kết quả in ra console của code trên đây.

Bạn có thể thấy số Thread đang chạy luôn luôn là 1. Cứ mỗi một Runnable được thực thi, thì con số Thread đang chờ (đúng hơn sẽ là các Runnable đang chờ) sẽ giảm dần.

Bài Thực Hành Số 2 – Xây Dựng Thread Pool Giống Như newFixedThreadPool

Chúng ta lại thử xây dựng Thread Pool như Bài thực hành số 2 của bài học trước. Để cùng nhau thấy rằng việc dùng Thread Pool với cách của bài trước hay bài hôm nay đều cho các kết quả tương đương, chỉ khác một chút cách khai báo tham số mà thôi.

Bài thực hành này mong muốn rằng mỗi một lần sẽ có 5 Thread được start. Cứ Thread nào kết thúc mà trong Queue vẫn còn Runnable đang đợi thì sẽ được Thread Pool start tiếp cho đủ số lượng corePoolSize mong muốn. Code sau cũng không khác Bài thực hành 1 trên kia lắm, chỉ thay các thông số corePoolSize và maximumPoolSize từ 1 lên 5 mà thôi.

public static void main(String args[]) {
    int corePoolSize = 5;
    int maximumPoolSize = 5;
    long keepAliveTime = 0L;
    TimeUnit unit = TimeUnit.MILLISECONDS;
    LinkedBlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Kết quả thực thi Pool này như bài học trước bạn cũng thấy. Đầu tiên 5 Thread được thực thi. Sau đó hễ Thread nào xong thì Thread khác được start. Đảm bảo luôn luôn không quá 5 Thread được thực thi trong Pool.

Sở dĩ hàng chờ ban đầu không có Thread nào là vì Thread nào đưa vào Queue cũng được thực thi ngay, không có Thread nào kịp vào chờ cả. Sau đó khi corePoolSize đã đầy, thì Queue mới chứa các Runnable.

À và vì việc các Thread được start và câu lệnh in ra console không “đồng bộ” với nhau khiến thứ tự in ra của chúng hơi lộn xộn, bạn nên nhìn theo số thứ tự của Runnable, như Runnable 1, Runnable 2,… sẽ thấy số thread đang chạy sẽ tăng theo đúng với số Thread trong Pool thật bạn nhé.

Nói thêm

Bài Thực Hành Số 3 – Xây Dựng Thread Pool Giống Như newCachedThreadPool

Tiếp tục với việc xây dựng Thread Pool tương đồng với Bài thực hành số 3 của bài học hôm trước, để chúng ta hiểu rõ hơn về cách kiểm soát ThreadPoolExecutor của bài hôm nay.

Thực sự thì với việc sử dụng Executors.newCachedThreadPool() từ bài hôm trước, có thể bạn cũng không mường tượng được hết công dụng của loại Thread Pool này. Hôm nay với việc khai báo thủ công Thread Pool này một lần nữa, sẽ hé lộ thêm nhiều thông tin đấy nhé. Trước hết hãy đến việc code cái nào.

public static void main(String args[]) {
    int corePoolSize = 0;
    int maximumPoolSize = Integer.MAX_VALUE;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    SynchronousQueue<Runnable> workQueue = new SynchronousQueue<>();

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Wow, cách sử dụng tham số khi này có một chút đặc biệt. Chúng ta hãy cùng xem qua.

• corePoolSize được chỉ định là 0, nhưng maximumPoolSize lại là giá trị lớn nhất mà kiểu Int có thể hỗ trợ. Điều này ban đầu giúp cho Thread Pool không quan tâm giá trị corePoolSize nữa mà sẽ thực thi với số lượng Thread lớn nhất mà hệ thống có thể đáp ứng được, vì giá trị maximumPoolSize khi này rất lớn.
• keepAliveTime được chỉ định 60 giây. Và bởi vì corePoolSize được chỉ định là 0, nên khi này tất cả các Thread đều bị áp đặt bởi việc đếm ngược 60 giây này. Các Thread không được start trong thời gian này sẽ bị hủy.
• workQueue khi này lại là một SynchronousQueue. Cũng là Queue như 2 bài thực hành trên thôi, nhưng việc dùng khác loại Queue này sẽ tác động đến cách Runnable được nằm trong hàng đợi như thế nào. Cụ thể thì SynchronousQueue khá đặc biệt, nó giúp start luôn Runnable được đưa vào và không nắm giữ chúng ở Queue gì cả. Các mục dưới của bài học sẽ làm rõ các Queue bạn yên tâm.

Kết quả thực thi cho thấy tất cả các Thread khi này đều được thực thi cùng lúc, và không có Thread nào phải chờ cả.

Bài Thực Hành Số 4 – Thread Pool Đạt Tới Mức maximumPoolSize

Chúng ta cùng xem. Với corePoolSize là 2, và maximumPoolSize là 4, Queue của chúng ta chỉ khai báo cho phép chứa được 6 Runnable. Thì với việc nhét 10 Runnable vào Pool, với hình chụp console bên dưới bạn sẽ thấy nhanh chóng Queue sẽ chứa đầy 6 Runnable. Việc Queue “đầy ắp” thế này khiến Thread Pool sẽ lấy tới con số lớn nhất là 4 Thread cùng chạy cùng một lúc, nếu không sẽ “vỡ đê” (thực ra nếu Thread Pool không mở rộng số Thread cần chạy, nhiều Runnable sẽ bị hủy nếu bạn xem tiếp các ví dụ bên dưới bài học).

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(6);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bài Thực Hành Số 5 – Thread Pool Start Ở Mức corePoolSize

Cũng với code trên, lần này chúng ta nới thêm số lượng Queue lên 15, khiến cho số lượng Runnable đưa vào Pool không đủ làm đầy Queue này, chính vì thế mà chúng ta thấy mỗi lần chỉ có 2 Thread được thực thi thôi, đó cũng chính là giá trị của corePoolSize.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(15);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bài Thực Hành Số 6 – Tự Xây Dựng threadFactory Trong Thread Pool

Cũng với code quen thuộc như các bài thực hành trước, nhưng dưới đây mình thay việc sử dụng MyRunnable bằng một lớp vô danh của Runnable để nhanh chóng sửa nội dung in ra console của nó khi được chạy.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(15);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Tạo một Runnable vô danh rồi in tên của lớp ra khi được thực thi
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " thực thi");
            }
        };
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bạn thấy rằng code trên chưa cũng chưa khai báo gì tới threadFactory cả và vì vậy mà tên của Runnable khi start sẽ như sau.

Bạn có thấy rằng các Thread này được nhóm chung một ThreadGroup nên chúng có cùng tên pool-1 ở đầu không. Còn tại sao chỉ chó thread-1 và thread-2 được thực thi trong khi chúng ta có tới 10 Runnable, điều này là vì 2 Thread được tạo ra với các tên thread-1 và thread-2 được tận dụng trở lại để khởi chạy các Runnable tiếp theo trong Queue, hệ thống không tạo ra thêm một Thread nào mới ngoài 2 Thread này hết. Bạn đã thấy sự lợi hại của Thread Pool trong việc tận dụng tối đa resource cho việc thực thi các tác vụ song song chưa nào.

Dưới đây là việc thay đổi nhỏ, bằng cách tạo ra một lớp vô danh nữa kế thừa từ lớp ThreadFactory và rồi override phương thức newThread của nó. Bằng cách này chúng ta sẽ kiểm soát tên Thread được khởi tạo thông qua hai tham số của Thread như sau.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(15);

    ThreadFactory threadFactory = new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "Thread của tôi");
        }
    };

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);

    // 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++) {
        // Tạo một Runnable vô danh rồi in tên của lớp ra khi được thực thi
        int index = i;
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " - " + index + " thực thi");
            }
        };
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Với việc thay đổi trên thì console sẽ như sau.

Bài Thực Hành Số 7 – Sử Dụng SynchronousQueue

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    SynchronousQueue<Runnable> workQueue = new SynchronousQueue<>();

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bạn thấy rằng Pool của chúng ta được nới rộng ra chạy với tối đa 4 Thread thì… boom, Exception bị tung ra và các Runnable còn chưa kịp start đều đã bị hủy hết.

Bài Thực Hành Số 8 – Sử Dụng LinkedBlockingQueue

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    LinkedBlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bạn xem Pool của chúng ta chỉ chạy mỗi 2 Thread một lần mà thôi, và không có Thread nào bị hủy do Queue chứa được rất nhiều.

Bài Thực Hành Số 9 – Sử Dụng ArrayBlockingQueue

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bài Thực Hành Số 10 – Xây Dựng RejectedExecutionHandler Của Chúng Ta

Với bài thực hành này chúng ta sẽ xây dựng một thể hiện của RejectedExecutionHandler, với thể hiện này chúng ta chỉ cần in ra console Runnable nào đã được hủy mà thôi. Code của Bài thực hành số 9 trên đây được xây dựng lại như sau.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
    RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println(r.toString() + " bị hủy.");
        }
    };

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Với việc chỉ định handler như trên, bạn thấy rằng khi này console sẽ in ra các Runnable bị hủy rõ ràng đúng không nào, thay vì tung ra một Exception và không rõ nghĩa gì cả ở Bài thực hành số 9.

Bài Thực Hành Số 11 – Sử dụng ThreadPoolExecutor.AbortPolicy

Bạn hãy để ý đến tham số cuối cùng của ThreadPoolExecutor như sau.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.AbortPolicy());

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Kết quả như mình có nói, không khác Bài thực hành số 9.

Bài Thực Hành Số 12 – Sử dụng ThreadPoolExecutor.CallerRunsPolicy

Nào chúng ta chỉ thay thế một chút tham số của code ở bài thực hành trên thôi.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.CallerRunsPolicy());

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Kết quả là đầy đủ 10 Runnable được thực thi.

Bài Thực Hành Số 13 – Sử dụng ThreadPoolExecutor.DiscardPolicy

Không nói nhiều, mời bạn cùng xem code.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.DiscardPolicy());

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bài Thực Hành Số 14 – Sử dụng ThreadPoolExecutor.DiscardOldestPolicy

Cũng chỉ với một thay đổi ở tham số.

public static void main(String args[]) {
    int corePoolSize = 2;
    int maximumPoolSize = 4;
    long keepAliveTime = 60L;
    TimeUnit unit = TimeUnit.SECONDS;
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);

    // Khai báo một Thread Pool thông qua ThreadPoolExecutor()
    ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.DiscardOldestPolicy());

    // 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++) {
        // Phương thức khởi tạo của MyRunnable có tham số name và executor truyền vào
        MyRunnable myRunnable = new MyRunnable("Runnable " + i, executor);
        executor.execute(myRunnable);
    }

    // Phương thức này đã nói ở phần ExecutorService của bài hôm trước
    executor.shutdown();
}

Bạn xem với 4 Runnable đầu không có gì phải bàn, nó là các Runnable được Thread Pool mang vào thực thi sớm nhất. Thế nhưng khi Runnable được lấy tiếp từ Queue để thực thi, thì chính là các Runnable số 9 & 10 được chỉ định, đây là các Runnable “trẻ nhất”, chúng được thêm vào Queue sau cùng, các Runnable “già” khác đã thăng thiên sớm rồi nhé.