import java.util.concurrent.CompletableFuture;

public class AskThread implements Runnable {
 CompletableFuture<Integer> re = null;

 public AskThread(CompletableFuture<Integer> re) {
 this.re = re;
 }

 @Override
 public void run() {
 int myRe = 0;
 try {
 myRe = re.get() * re.get();
 } catch (Exception e) {
 }
 System.out.println(myRe);
 }

 public static void main(String[] args) throws InterruptedException {
 final CompletableFuture<Integer> future = new CompletableFuture<Integer>();
 new Thread(new AskThread(future)).start();
 // 模拟长时间的计算过程
 Thread.sleep(1000);
 // 告知完成结果
 future.complete(60);
 }
}

public static Integer calc(Integer para) {
 try {
 // 模拟一个长时间的执行
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 }
 return para * para;
 }

 public static void main(String[] args) throws InterruptedException,
 ExecutionException {
 final CompletableFuture<Integer> future = CompletableFuture
 .supplyAsync(() -> calc(50));
 System.out.println(future.get());
 }
CompletableFuture的流式调用：

public static Integer calc(Integer para) {
 try {
 // 模拟一个长时间的执行
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 }
 return para * para;
 }

 public static void main(String[] args) throws InterruptedException,
 ExecutionException {
 CompletableFuture<Void> fu = CompletableFuture
 .supplyAsync(() -> calc(50))
 .thenApply((i) -> Integer.toString(i))
 .thenApply((str) -> """ + str + """)
 .thenAccept(System.out::println);
 fu.get();
 }

public static Integer calc(Integer para) {
 return para / 2;
 }

 public static void main(String[] args) throws InterruptedException,
 ExecutionException {
 CompletableFuture<Void> fu = CompletableFuture
 .supplyAsync(() -> calc(50))
 .thenCompose(
  (i) -> CompletableFuture.supplyAsync(() -> calc(i)))
 .thenApply((str) -> """ + str + """)
 .thenAccept(System.out::println);
 fu.get();
 }

import java.util.concurrent.locks.StampedLock;

public class Point {
 private double x, y;
 private final StampedLock sl = new StampedLock();

 void move(double deltaX, double deltaY) { // an exclusively locked method
 long stamp = sl.writeLock();
 try {
 x += deltaX;
 y += deltaY;
 } finally {
 sl.unlockWrite(stamp);
 }
 }

 double distanceFromOrigin() { // A read-only method
 long stamp = sl.tryOptimisticRead();
 double currentX = x, currentY = y;
 if (!sl.validate(stamp)) {
 stamp = sl.readLock();
 try {
 currentX = x;
 currentY = y;
 } finally {
 sl.unlockRead(stamp);
 }
 }
 return Math.sqrt(currentX * currentX + currentY * currentY);
 }
}