• 多线程手写Future模式


    future模式

    在进行耗时操作的时候,线程直接阻塞,我们需要优化这样的代码,让他再启动一个线程,不阻塞.可以执行下面的代码. 这个时候我们就用到了未来者模式

    future设计类

    只有一个方法 

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

    futureTask 类

    public interface FutureTask<T> {
    
        T call();
    
    }

    asyncFuture 类是fufure的实现类

    /**
     * @Created by xiaodao
     */
    public class AsynFuture<T> implements Future<T> {
    
        private volatile boolean done = true;
    
        private T result;
    
    
        public void done(T result){
            synchronized (this){
                this.result= result;
                this.done=false;
                this.notifyAll();
            }
    
        }
    
        @Override
        public T get() throws InterruptedException {
    
            synchronized (this){
                while (done){
                    this.wait();
                }
            }
            return result;
        }
    }

    FutureService 

      讲 fufure类 和futuretask类连接起来

    public class FutureService {
    
    
        public <T> Future<T> subimt(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;
        }
    
    
    }

    里面有俩种方法,一种是调用get的时候会阻塞,一种通过callable的方式回调回来,这样更加合理

    提供一个测试了类

    /**
     * Future        ->代表的是未来的一个凭据
     * FutureTask    ->将你的调用逻辑进行了隔离
     * FutureService ->桥接 Future和 FutureTask
     */
    public class SyncInvoker {
    
        public static void main(String[] args) throws InterruptedException {
    
            /**
             * 这种方式在调用的时候被阻塞住了.不好
             */
            FutureService futureService = new FutureService();
            Future<String> future = futureService.subimt(() -> {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                return "FINISH";
            });
            /**
             * 不阻塞
             */
            futureService.submit(() -> {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                return "FINISH-callable";
            },System.out::println);
            System.out.println(future.get());
            System.out.println("other thing .......");
    
            Thread.sleep(1000);
            System.out.println("==========");
    
        }
    
    }

    在调用的时候,就可以看到我们想要的效果,阻塞方式的话,会把主线程阻塞掉,非阻塞方式的话,不会当前进程会等的回调之后停止.

  • 相关阅读:
    免费的编程中文书籍索引 from github
    win7 Python 环境 准备 配置
    SQL Server 2008 允许远程链接,适用于广域网和局域网
    CTP API开发期货自动交易平台概论
    一步一步重写 CodeIgniter 框架 (4) —— load_class 管理多个对象实例的思路
    一步一步重写 CodeIgniter 框架 (3) —— 用面向对象重构代码
    一步一步重写 CodeIgniter 框架 (2) —— 实现简单的路由功能
    一步一步重写 CodeIgniter 框架 (1) —— url 如何映射到具体的方法
    一步一步重写 CodeIgniter 框架 -- 原因和思路
    GDI双缓冲绘图
  • 原文地址:https://www.cnblogs.com/bj-xiaodao/p/10774661.html
Copyright © 2020-2023  润新知