Java Concurrency - Futures và Callable

Đối tượng java.util.concurrent.Callable có thể trả về kết quả tính toán được thực hiện bởi một luồng, ngược lại với giao diện runnable chỉ có thể chạy luồng. Đối tượng Callable trả về đối tượng Future cung cấp các phương thức để theo dõi tiến trình của một tác vụ đang được thực thi bởi một luồng. Đối tượng trong tương lai có thể được sử dụng để kiểm tra trạng thái của một Callable và sau đó truy xuất kết quả từ Callable sau khi chuỗi hoàn thành. Nó cũng cung cấp chức năng thời gian chờ.

Cú pháp

//submit the callable using ThreadExecutor
//and get the result as a Future object
Future<Long> result10 = executor.submit(new FactorialService(10));
 
//get the result using get method of the Future object
//get method waits till the thread execution and then return the result of the execution.
Long factorial10 = result10.get();

Thí dụ

Chương trình TestThread sau đây cho thấy việc sử dụng Futures và Callable trong môi trường dựa trên luồng.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException,
      ExecutionException {

      ExecutorService executor = Executors.newSingleThreadExecutor();

      System.out.println("Factorial Service called for 10!");
      Future<Long> result10 = executor.submit(new FactorialService(10));

      System.out.println("Factorial Service called for 20!");
      Future<Long> result20 = executor.submit(new FactorialService(20));

      Long factorial10 = result10.get();
      System.out.println("10! = " + factorial10);

      Long factorial20 = result20.get();
      System.out.println("20! = " + factorial20);

      executor.shutdown();
   }  

   static class FactorialService implements Callable<Long> {
      private int number;

      public FactorialService(int number) {
         this.number = number;
      }

      @Override
      public Long call() throws Exception {
         return factorial();
      }

      private Long factorial() throws InterruptedException {
         long result = 1; 
         
         while (number != 0) { 
            result = number * result; 
            number--; 
            Thread.sleep(100); 
         }
         return result;	
      }
   }
}

Điều này sẽ tạo ra kết quả sau.

Đầu ra

Factorial Service called for 10!
Factorial Service called for 20!
10! = 3628800
20! = 2432902008176640000