@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class FutureTaskDemo {
 
  public static void main(String[] args) throws ExecutionException, InterruptedException {
    int[] data = new int[100000];
    Random random = new Random();
    for (int i = 0; i < 100000; i++) {
      data[i] = random.nextInt(10000);
    }
    @SuppressWarnings("unchecked")
    FutureTask<Integer>[] tasks = (FutureTask<Integer>[]) Array.newInstance(FutureTask.class, 10);
    // 設(shè)置10個 futuretask 任務(wù)計算數(shù)組當(dāng)中數(shù)據(jù)的和
    for (int i = 0; i < 10; i++) {
      int idx = i;
      tasks[i] = new FutureTask<>(() -> {
        int sum = 0;
        for (int k = idx * 10000; k < (idx + 1) * 10000; k++) {
          sum += data[k];
        }
        return sum;
      });
    }
    // 開啟線程執(zhí)行 futureTask 任務(wù)
    for (FutureTask<Integer> futureTask : tasks) {
      new Thread(futureTask).start();
    }
    int threadSum = 0;
    for (FutureTask<Integer> futureTask : tasks) {
      threadSum += futureTask.get();
    }
    int sum = Arrays.stream(data).sum();
    System.out.println(sum == threadSum); // 結(jié)果始終為 true
  }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
 
public class LockDemo {
 
  private ReentrantLock lock;
  private Condition condition;
 
  LockDemo() {
    lock = new ReentrantLock();
    condition = lock.newCondition();
  }
 
  public void blocking() {
    lock.lock();
    try {
      System.out.println(Thread.currentThread() + " 準(zhǔn)備等待被其他線程喚醒");
      condition.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }finally {
      lock.unlock();
    }
  }
 
  public void inform() throws InterruptedException {
    // 先休眠兩秒 等他其他線程先阻塞
    TimeUnit.SECONDS.sleep(2);
    lock.lock();
    try {
      System.out.println(Thread.currentThread() + " 準(zhǔn)備喚醒其他線程");
      condition.signal(); // 喚醒一個被 await 方法阻塞的線程
      // condition.signalAll(); // 喚醒所有被 await 方法阻塞的線程
    }finally {
      lock.unlock();
    }
  }
 
  public static void main(String[] args) {
    LockDemo lockDemo = new LockDemo();
    Thread thread = new Thread(() -> {
      lockDemo.blocking(); // 執(zhí)行阻塞線程的代碼
    }, "Blocking-Thread");
    Thread thread1 = new Thread(() -> {
      try {
        lockDemo.inform(); // 執(zhí)行喚醒線程的代碼
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }, "Inform-Thread");
    thread.start();
    thread1.start();
  }
}

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
 
// 這里需要實(shí)現(xiàn) Runnable 接口，因?yàn)樾枰獙⑦@個對象放入 Thread 類當(dāng)中
// 而 Thread 要求傳入的對象實(shí)現(xiàn)了 Runnable 接口
public class MyFutureTask<V> implements Runnable {
 
  private final Callable<V> callable;
  private Object returnVal; // 這個表示我們最終的返回值
  private final ReentrantLock lock;
  private final Condition condition;
 
  public MyFutureTask(Callable<V> callable) {
    // 將傳入的 callable 對象存儲起來 方便在后面的 run 方法當(dāng)中調(diào)用
    this.callable = callable;
    lock = new ReentrantLock();
    condition = lock.newCondition();
  }
 
  @SuppressWarnings("unchecked")
  public V get(long timeout, TimeUnit unit) {
    if (returnVal != null) // 如果符合條件 說明 call 函數(shù)已經(jīng)執(zhí)行完成 返回值已經(jīng)不為 null 了
      return (V) returnVal; // 直接將結(jié)果返回即可 這樣不用競爭鎖資源 提高程序執(zhí)行效率
    lock.lock();
    try {
      // 這里需要進(jìn)行二次判斷 (雙重檢查)
      // 因?yàn)槿绻粋€線程在第一次判斷 returnVal 為空
      // 然后這個時候它可能因?yàn)楂@取鎖而被掛起
      // 而在被掛起的這段時間，call 可能已經(jīng)執(zhí)行完成
      // 如果這個時候不進(jìn)行判斷直接執(zhí)行 await方法
      // 那后面這個線程將無法被喚醒
      if (returnVal == null)
        condition.await(timeout, unit);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
    return (V) returnVal;
  }
 
  @SuppressWarnings("unchecked")
  public V get() {
    if (returnVal != null)
      return (V) returnVal;
    lock.lock();
    try {
      // 同樣的需要進(jìn)行雙重檢查
      if (returnVal == null)
      	condition.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
    return (V) returnVal;
  }
 
 
  @Override
  public void run() {
    if (returnVal != null)
      return;
    try {
      // 在 Runnable 的 run 方法當(dāng)中
      // 執(zhí)行 Callable 方法的 call 得到返回結(jié)果
      returnVal = callable.call();
    } catch (Exception e) {
      e.printStackTrace();
    }
    lock.lock();
    try {
      // 因?yàn)橐呀?jīng)得到了結(jié)果
      // 因此需要將所有被 await 方法阻塞的線程喚醒
      // 讓他們從 get 方法返回
      condition.signalAll();
    }finally {
      lock.unlock();
    }
  }
	// 下面是測試代碼
  public static void main(String[] args) {
    MyFutureTask<Integer> ft = new MyFutureTask<>(() -> {
      TimeUnit.SECONDS.sleep(2);
      return 101;
    });
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get(100, TimeUnit.MILLISECONDS)); // 輸出為 null
    System.out.println(ft.get()); // 輸出為 101
  }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
  int[] data = new int[100000];
  Random random = new Random();
  for (int i = 0; i < 100000; i++) {
    data[i] = random.nextInt(10000);
  }
  @SuppressWarnings("unchecked")
  MyFutureTask<Integer>[] tasks = (MyFutureTask<Integer>[]) Array.newInstance(MyFutureTask.class, 10);
  for (int i = 0; i < 10; i++) {
    int idx = i;
    tasks[i] = new MyFutureTask<>(() -> {
      int sum = 0;
      for (int k = idx * 10000; k < (idx + 1) * 10000; k++) {
        sum += data[k];
      }
      return sum;
    });
  }
  for (MyFutureTask<Integer> MyFutureTask : tasks) {
    new Thread(MyFutureTask).start();
  }
  int threadSum = 0;
  for (MyFutureTask<Integer> MyFutureTask : tasks) {
    threadSum += MyFutureTask.get();
  }
  int sum = Arrays.stream(data).sum();
  System.out.println(sum == threadSum); // 輸出結(jié)果為 true
}