利用Java怎么實現異步調用轉同步

利用Java怎么實現異步調用轉同步？很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

1.構造一個異步調用

首先，寫demo需要先寫基礎設施，這里的話主要是需要構造一個異步調用模型。異步調用類:

public class AsyncCall {

  private Random random = new Random(System.currentTimeMillis());

  private ExecutorService tp = Executors.newSingleThreadExecutor();

  //demo1,2,4,5調用方法
  public void call(BaseDemo demo){

    new Thread(()->{
      long res = random.nextInt(10);

      try {
        Thread.sleep(res*1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      demo.callback(res);
    }).start();


  }

  //demo3調用方法
  public Future<Long> futureCall(){

    return tp.submit(()-> {
      long res = random.nextInt(10);

      try {
        Thread.sleep(res*1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      return res;
    });

  }

  public void shutdown(){

    tp.shutdown();

  }

}

我們主要關心call方法，這個方法接收了一個demo參數，并且開啟了一個線程，在線程中執行具體的任務，并利用demo的callback方法進行回調函數的調用。大家注意到了這里的返回結果就是一個[0,10)的長整型，并且結果是幾，就讓線程sleep多久——這主要是為了更好地觀察實驗結果，模擬異步調用過程中的處理時間。
至于futureCall和shutdown方法，以及線程池tp都是為了demo3利用Future來實現做準備的。
demo的基類:

public abstract class BaseDemo {

  protected AsyncCall asyncCall = new AsyncCall();

  public abstract void callback(long response);

  public void call(){
    System.out.println("發起調用");
    asyncCall.call(this);
    System.out.println("調用返回");
  }

}

BaseDemo非常簡單，里面包含一個異步調用類的實例，另外有一個call方法用于發起異步調用，當然還有一個抽象方法callback需要每個demo去實現的——主要在回調中進行相應的處理來達到異步調用轉同步的目的。

2. 使用wait和notify方法

這個方法其實是利用了鎖機制，直接貼代碼：

public class Demo1 extends BaseDemo{

  private final Object lock = new Object();

  @Override
  public void callback(long response) {
    System.out.println("得到結果");
    System.out.println(response);
    System.out.println("調用結束");

    synchronized (lock) {
      lock.notifyAll();
    }

  }

  public static void main(String[] args) {

    Demo1 demo1 = new Demo1();

    demo1.call();

    synchronized (demo1.lock){
      try {
        demo1.lock.wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    System.out.println("主線程內容");

  }
}

可以看到在發起調用后，主線程利用wait進行阻塞，等待回調中調用notify或者notifyAll方法來進行喚醒。注意，和大家認知的一樣，這里wait和notify都是需要先獲得對象的鎖的。在主線程中最后我們打印了一個內容，這也是用來驗證實驗結果的，如果沒有wait和notify，主線程內容會緊隨調用內容立刻打印；而像我們上面的代碼，主線程內容會一直等待回調函數調用結束才會進行打印。
沒有使用同步操作的情況下，打印結果：

發起調用
調用返回
主線程內容
得到結果
1
調用結束

而使用了同步操作后：

發起調用
調用返回
得到結果
9
調用結束
主線程內容

3. 使用條件鎖

和方法一的原理類似：

public class Demo2 extends BaseDemo {

  private final Lock lock = new ReentrantLock();
  private final Condition con = lock.newCondition();

  @Override
  public void callback(long response) {

    System.out.println("得到結果");
    System.out.println(response);
    System.out.println("調用結束");
    lock.lock();
    try {
      con.signal();
    }finally {
      lock.unlock();
    }

  }

  public static void main(String[] args) {

    Demo2 demo2 = new Demo2();

    demo2.call();

    demo2.lock.lock();

    try {
      demo2.con.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }finally {
      demo2.lock.unlock();
    }
    System.out.println("主線程內容");
  }
}

基本上和方法一沒什么區別，只是這里使用了條件鎖，兩者的鎖機制有所不同。

4. Future

使用Future的方法和之前不太一樣，我們調用的異步方法也不一樣。

public class Demo3{

  private AsyncCall asyncCall = new AsyncCall();

  public Future<Long> call(){

    Future<Long> future = asyncCall.futureCall();

    asyncCall.shutdown();

    return future;

  }

  public static void main(String[] args) {

    Demo3 demo3 = new Demo3();

    System.out.println("發起調用");
    Future<Long> future = demo3.call();
    System.out.println("返回結果");

    while (!future.isDone() && !future.isCancelled());

    try {
      System.out.println(future.get());
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (ExecutionException e) {
      e.printStackTrace();
    }

    System.out.println("主線程內容");

  }
}

我們調用futureCall方法，方法中會想線程池tp提交一個Callable，然后返回一個Future，這個Future就是我們demo3中call中得到的，得到future對象之后就可以關閉線程池啦，調用asyncCall的shutdown方法。關于關閉線程池這里有一點需要注意，我們回過頭來看看asyncCall的shutdown方法：

public void shutdown(){

    tp.shutdown();

  }

發現只是簡單調用了線程池的shutdown方法，然后我們說注意的點，這里最好不要用tp的shutdownNow方法，該方法會試圖去中斷線程中中正在執行的任務；也就是說，如果使用該方法，有可能我們的future所對應的任務將被中斷，無法得到執行結果。
然后我們關注主線程中的內容，主線程的阻塞由我們自己來實現，通過future的isDone和isCancelled來判斷執行狀態，一直到執行完成或被取消。隨后，我們打印get到的結果。

5. 使用CountDownLatch

使用CountDownLatch或許是日常編程中最常見的一種了，也感覺是相對優雅的一種：

public class Demo4 extends BaseDemo{

  private final CountDownLatch countDownLatch = new CountDownLatch(1);

  @Override
  public void callback(long response) {

    System.out.println("得到結果");
    System.out.println(response);
    System.out.println("調用結束");

    countDownLatch.countDown();

  }

  public static void main(String[] args) {

    Demo4 demo4 = new Demo4();

    demo4.call();

    try {
      demo4.countDownLatch.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    System.out.println("主線程內容");

  }
}

正如大家平時使用的那樣，此處在主線程中利用CountDownLatch的await方法進行阻塞，在回調中利用countDown方法來使得其他線程await的部分得以繼續運行。
當然，這里和demo1和demo2中都一樣，主線程中阻塞的部分，都可以設置一個超時時間，超時后可以不再阻塞。

6. 使用CyclicBarrier

CyclicBarrier的情況和CountDownLatch有些類似：

public class Demo5 extends BaseDemo{

  private CyclicBarrier cyclicBarrier = new CyclicBarrier(2);


  @Override
  public void callback(long response) {

    System.out.println("得到結果");
    System.out.println(response);
    System.out.println("調用結束");

    try {
      cyclicBarrier.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (BrokenBarrierException e) {
      e.printStackTrace();
    }

  }

  public static void main(String[] args) {

    Demo5 demo5 = new Demo5();

    demo5.call();

    try {
      demo5.cyclicBarrier.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (BrokenBarrierException e) {
      e.printStackTrace();
    }

    System.out.println("主線程內容");

  }
}

大家注意一下，CyclicBarrier和CountDownLatch僅僅只是類似，兩者還是有一定區別的。比如，一個可以理解為做加法，等到加到這個數字后一起運行；一個則是減法，減到0繼續運行。一個是可以重復計數的；另一個不可以等等等等。
另外，使用CyclicBarrier的時候要注意兩點。第一點，初始化的時候，參數數字要設為2，因為異步調用這里是一個線程，而主線程是一個線程，兩個線程都await的時候才能繼續執行，這也是和CountDownLatch區別的部分。第二點，也是關于初始化參數的數值的，和這里的demo無關，在平時編程的時候，需要比較小心，如果這個數值設置得很大，比線程池中的線程數都大，那么就很容易引起死鎖了。

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。