4 cách viết code đa luồng trong Java

Đa luồng là một phương pháp viết code để thực thi nhiều tác vụ song song. Java hỗ trợ tuyệt vời cho viết code đa luồng ngay từ phiên bản Java 1.0. Những cải tiến mới đây trong Java đã tăng số cách mà code được cấu trúc hóa để kết hợp nhiều luồng trong các chương trình Java.

Trong bài viết này, Quantrimang.com so sánh một vài lựa chọn để viết code đa luồng, hy vọng bạn đọc có thể chọn được cho mình một cách phù hợp để áp dụng trong dự án Java tiếp theo của mình.

• Cách khắc phục lỗi không cài được Java
• Cuối cùng các trường đại học lớn đã nhận ra Java là một ngôn ngữ tệ hại nếu dùng để dạy nhập môn lập trình

Cách 1: Mở rộng lớp Thread

Java cung cấp lớp Thread có thể mở rộng để thực hiện run(). run() chính là nơi để thực thi tác vụ. Khi bạn muốn khởi động một tác vụ trong thread riêng của nó, có thể tạo instance trong class này và gọi start(). Điều này sẽ bắt đầu thực hiện thread và chạy để hoàn thành (hoặc chấm dứt) tác vụ.

Đây là một lớp Thread đơn giản thực hiện tác vụ ngủ trong một khoảng thời gian xác định như là một cách để mô phỏng một hoạt động chạy trong thời gian dài.

public class MyThread extends Thread
{
    private int sleepFor;

    public MyThread(int sleepFor) {
        this.sleepFor = sleepFor;
    }

    @Override
    public void run() {
        System.out.printf("[%s] thread starting\n",
        Thread.currentThread().toString());
        try { Thread.sleep(this.sleepFor); }
        catch(InterruptedException ex) {}
        System.out.printf("[%s] thread ending\n",
        Thread.currentThread().toString());
    }
}

Tạo instance của lớp Thread này bằng cách đưa cho nó số mili giây để ngủ.

MyThread worker = new MyThread(sleepFor);

Khởi chạy tiến trình của luồng worker trên bằng cách gọi phương thức start() của nó. Phương thức này sẽ trả về control ngay lập tức cho caller mà không cần đợi luồng chấm dứt.

worker.start();
System.out.printf("[%s] main thread\n", Thread.currentThread().toString());

Và đây là đầu ra khi chạy code này. Nó chỉ ra rằng thread chính được in trước khi luồng worker hoàn thành.

[Thread[main,5,main]] main thread
[Thread[Thread-0,5,main]] thread starting
[Thread[Thread-0,5,main]] thread ending

Bởi vì không có lệnh nào sau khi bắt đầu luồng worker, luồng chính sẽ đợi cho luồng worker kết thúc trước khi chương trình thoát. Điều này cho phép luồng worker hoàn thành hết các tác vụ của mình.

Cách 2: Sử dụng Thread Instance với Runnable

Java cũng cung cấp một giao diện gọi là Runnable, có thể được thực hiện bởi một lớp worker để thực thi tác vụ trong phương thức run() của nó. Đây là một cách khác để tạo lớp worker thay vì mở rộng lớp Thread (được mô tả bên trên).

Đây là cách thực hiện lớp worker với Runnable thay vì mở rộng Thread.

public class MyThread2 implements Runnable {
    // same as above
}

Ưu điểm của cách này lớp worker có thể mở rộng một lớp cụ thể theo miền trong một phân cấp lớp (class hierarchy). Điều đó có nghĩa là gì? Ví dụ, bạn có lớp Fruit chứa những đặc điểm chung thuộc về trái cây. Bây giờ bạn muốn thực hiện một lớp Papaya với những đặc điểm nào đó của trái cây. Bạn có thể làm điều đó bằng code sau:

public class Fruit {
    // fruit specifics here
}

public class Papaya extends Fruit {
    // override behavior specific to papaya here
}

Bây giờ, giả sử có một số tác vụ tốn thời gian mà Papaya cần hỗ trợ, có thể được thực hiện trong một luồng riêng biệt. Trường hợp này có thể được xử lý bằng cách yêu cầu lớp Papaya thực thi Runnable và cung cấp phương thức run() nơi mà nhiệm vụ này được thực hiện.

public class Papaya extends Fruit implements Runnable {
    // override behavior specific to papaya here

    @Override
    public void run() {
        // time consuming task here.
    }
}

Để khởi động luồng worker, tạo một instance của lớp worker và giao nó cho instance Thread trong quá trình tạo. Khi phương thức start() của Thread được gọi, nhiệm vụ sẽ thực hiện trong một luồng riêng biệt.

Papaya papaya = new Papaya();
// set properties and invoke papaya methods here.
Thread thread = new Thread(papaya);
thread.start();

Và đó là cách đơn giản để sử dụng Runnable thực hiện tác vụ trong một luồng.

Cách 3: Triển khai Runnable với ExecutorService

Bắt đầu từ phiên bản 1.5, Java có thêm ExecutorService như một mô hình mới để tạo và quản lý các luồng trong một chương trình. Nó tổng quát khái niệm về việc triển khai luồng bằng cách trừu tượng hóa việc tạo các luồng.

Điều này là do bạn có thể chạy nhiều tác vụ trong nhóm luồng, sử dụng luồng riêng biệt cho mỗi tác vụ. Nhờ đó, chương trình có thể theo dõi và quản lý xem có bao nhiêu luồng được sử dụng cho các tác vụ worker.

Giả sử bạn có 100 tác vụ worker đang chờ để thực hiện. Nếu bắt đầu một luồng cho mỗi worker thì sẽ có 100 luồng trong chương trình. Điều này có thể dẫn tới tình trạng thắt nút cổ chai ở những nơi khác trong chương trình. Thay vào đó, nếu sử dụng nhóm luồng, 10 luồng được phân bổ trước, 100 tác vụ sẽ được thực thi bởi những luồng này, lần lượt từng nhóm một, và chương trình sẽ không bị thiếu tài nguyên. Ngoài ra, nhóm luồng này có thể được cấu hình để thực hiện thêm những nhiệm vụ bổ sung.

ExecutorService chấp nhận một tác vụ Runnable và chạy tác vụ vào một thời điểm thích hợp. Phương thức submit() trả về instance cảu một lớp được gọi là Future, cho phép caller theo dõi trạng thái của tác vụ. Cụ thể, phương thức get() cho phép caller đợi cho đến khi tác vụ hoàn thành (và cung cấp code trả về, nếu có).

Trong ví dụ dưới đây, chúng ta có thể tạo ExecutorService sử dụng phương thức tĩnh newSingleThreadExecutor(), nhằm tạo một luồng đơn để thực hiện các tác vụ. Nếu có nhiều tác vụ được submit trong khi một tác vụ khác đang chạy thì ExcecutorService sẽ sắp xếp những tác vụ này để thực thi tiếp theo, sau khi tác vụ trước kết thúc.

Đây là ví dụ cho mô tả dài loằng ngoằng ở trên:

ExecutorService esvc = Executors.newSingleThreadExecutor();
Runnable worker = new MyThread2(sleepFor);
Future<?> future = esvc.submit(worker);
System.out.printf("[%s] main thread\n", Thread.currentThread().toString());
future.get();
esvc.shutdown();

Lưu ý rằng, ExecutorService phải được đóng lại đúng cách khi không cần dùng đến nó để submit các tác vụ tiếp theo.

Cách 4: Sử dụng Callable với ExecutorService

Trong phiên bản 1.5 Java giới thiệu Callable mới, khá giống với Runnable. Khác biệt là phương thức thưc hiện (được gọi là call() thay vì run()) có thể trả về một giá trị. Nó cũng có thể khai báo một Exception được đưa vào.

ExecutorService có thể chấp nhận các tác vụ được thực hiện như Callable và trả về Future với giá trị được trả về bởi phương thức khi kết thúc tác vụ.

Đây là ví dụ về lớp Mango, mở rộng lớp Fruit được định nghĩa trước đó và thực hiện Callable. Một tác vụ nặng và tốn nhiều thời gian sẽ được thực hiện trong call().

public class Mango extends Fruit implements Callable {
  public Integer call() {
    // expensive computation here
    return new Integer(0);
  }
}

Và đây là code để submit môt instance của lớp vào ExcecutorService. Đoạn code bên dưới cũng đợi đến khi tác vụ hoàn thành và in giá trị nó trả về.

ExecutorService esvc = Executors.newSingleThreadExecutor();

MyCallable worker = new MyCallable(sleepFor);
Future future = esvc.submit(worker);
System.out.printf("[%s] main thread\n", Thread.currentThread().toString());
System.out.println("Task returned: " + future.get());
esvc.shutdown();

Bạn thích cách tạo thread nào hơn?

Trong bài này, chúng ta có phương pháp để viết code đa luồng trong Java. Bao gồm:

• Mở rộng lớp Thread là cơ bản nhất và đã có sẵn từ Java 1.0.
• Nếu bạn có một class mà phải mở rộng một số class khác trong một hệ thống phân cấp lớp, thì có thể thực hiện các Runnable.
• Một cơ sở hiện đại hơn cho việc tạo ra luồng là ExecutorService có thể chấp nhận instance Runnable như là một nhiệm vụ để chạy. Ưu điểm của phương pháp này là bạn có thể sử dụng một thread pool để thực thi nhiệm vụ. Một thread pool giúp bảo vệ tài nguyên bằng cách sử dụng lại thread.
• Cuối cùng, bạn cũng có thể tạo ra một tác vụ bằng cách triển khai Callable và submit tác vụ tới ExecutorService.

Hy vọng bài viết có thể giúp bạn một phần nào đó!