java 多线程设计模式-future模式

java 多线程设计模式-future模式

MFuture

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

    T get(int timeout, TimeUnit unit) throws InterruptedException;

    boolean isDone();

    void finished(T data);
}

实现：

public class MFutureTask<T> implements MFuture<T> {
    private T data;
    private boolean done;

    public MFutureTask() {
        this.done = false;
    }

    @Override
    public T get() throws InterruptedException {
        synchronized (this) {
            while (!done) {
                this.wait();
            }
            return data;
        }
    }

    @Override
    public T get(int timeout, TimeUnit unit) throws InterruptedException {
        synchronized (this) {
            long milSec = TimeUnit.MILLISECONDS.convert(timeout, unit);
            this.wait(milSec);
        }
        return data;
    }

    @Override
    public boolean isDone() {
        return this.done;
    }

    @Override
    public void finished(T data) {
        synchronized (this) {
            this.data = data;
            this.done = true;
            this.notifyAll();
        }
    }
}

TaskService

处理提交任务

public interface TaskService {

    <OUT> MFuture<OUT> submit(MTask<OUT> task);

    static TaskService newTaskService() {
        return new TaskServiceImpl();
    }

    void shutdown();

}

实现：

@Slf4j
public class TaskServiceImpl implements TaskService {

    @Setter
    private ExecutorService executorService;

    public TaskServiceImpl() {
        this.executorService = Executors.newFixedThreadPool(4, new ThreadFactory() {
            AtomicInteger seq = new AtomicInteger(0);

            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("Task-" + seq.getAndIncrement());
                return thread;
            }
        });
    }

    @Override
    public <OUT> MFuture<OUT> submit(MTask<OUT> task) {
        MFutureTask<OUT> futureTask = new MFutureTask<>();
        executorService.execute(() -> {
            log.info("{} before submit task", Thread.currentThread().getName());
            OUT result = task.run();
            futureTask.finished(result);
        });
        log.info("{}-submit task", Thread.currentThread().getName());
        return futureTask;
    }


    @Override
    public void shutdown() {
        log.info("task-service is shutdown...");
        executorService.shutdown();
    }
}

测试

public class FutureMain {

    public static void main(String[] args) throws InterruptedException {
        TaskService taskService = TaskService.newTaskService();

        MTask<String> task = new MTask<String>() {
            @Override
            public String run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " start");
                    int sep = new Random(5).nextInt(10);
                    TimeUnit.SECONDS.sleep(sep);
                    System.out.println(Thread.currentThread().getName() + " sleep " + sep + " sec");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "success";
            }
        };
        MFuture<String> future = taskService.submit(task);
        String s1 = future.get(1, TimeUnit.SECONDS);
        System.out.println(s1);
        System.out.println(future.isDone());
        String s = future.get();
        System.out.println(s);
        taskService.shutdown();
    }
}

结果：

09:21:03.484 [main] INFO TaskServiceImpl - main-submit task
09:21:03.484 [Task-0] INFO askServiceImpl - Task-0 before submit task
Task-0 start
null
false
Task-0 sleep 7 sec
success
09:21:10.487 [main] INFO TaskServiceImpl - task-service is shutdown...