Java多線程中Future設計模式怎么用

這篇文章將為大家詳細講解有關Java多線程中Future設計模式怎么用，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

Future -> 代表的是未來的一個憑據

public interface Future<T> {
    T get() throws InterruptedException;
}

AsynFuture -> Future具體實現類

public class AsynFuture<T> implements Future<T> {

    private volatile boolean done = false;

    private T result;

    public void done(T result){
        synchronized (this){
            this.result = result;
            this.done = true;
            this.notifyAll();
        }
    }
    /**
     * 輪詢 沒有完成等待
     */
    @Override
    public T get() throws InterruptedException {
        synchronized (this) {
            while (!done) {
                this.wait();
            }
        }
        return result;
    }
}

FutureService -> 橋接Future和FutureTask

public class FutureService {

    /**
     * 需進程等待
     */
    public <T> Future<T> submit(final FutureTask<T> task) {

        AsynFuture<T> asynFuture = new AsynFuture<>();

        new Thread(() -> {

            T result = task.call();
            asynFuture.done(result);

        }).start();
        return asynFuture;
    }

    /**
     * 運行完 自動回調
     * 無需進程等待
     */
    public <T> Future<T> submit(final FutureTask<T> task, final Consumer<T> consumer) {

        AsynFuture<T> asynFuture = new AsynFuture<>();
        new Thread(() -> {
            T result = task.call();
            asynFuture.done(result);
            consumer.accept(result);
        }).start();
        return asynFuture;
    }
}

FutureTask -> 將你的調用邏輯進行了隔離

public interface FutureTask<T> {

    T call();
}

需要時回調：

/**
 * Future        -> 代表的是未來的一個憑據
 * FutureTask    -> 將你的調用邏輯進行了隔離
 * FutureService -> 橋接Future和FutureTask
 */
public class SyncInvoker {

    public static void main(String[] args) throws InterruptedException {

        FutureService futureService = new FutureService();
        Future<String> future = futureService.submit(() -> {
            try {
                Thread.sleep(10001);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "FINISH";
        });

        System.out.println("==============");
        System.out.println("do other thing.");
        Thread.sleep(1000);

        System.out.println("==============");

        /**
         * 調用也形成了阻塞
         */
        System.out.println(future.get());
    }
}

運行：

==============
do other thing.
==============
FINISH

運行完自動回調:

//**
 * Future        -> 代表的是未來的一個憑據
 * FutureTask    -> 將你的調用邏輯進行了隔離
 * FutureService -> 橋接Future和FutureTask
 */
public class SyncInvoker {

    public static void main(String[] args) throws InterruptedException {

        FutureService futureService = new FutureService();
        futureService.submit(() -> {
            try {
                Thread.sleep(10001);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "FINISH";
        },System.out::println);

        System.out.println("==============");
        System.out.println("do other thing.");
        Thread.sleep(1000);
        System.out.println("==============");
    }
}

關于“Java多線程中Future設計模式怎么用”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。