zoukankan      html  css  js  c++  java
  • 多线程手写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("==========");
    
        }
    
    }

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

  • 相关阅读:
    从尾到头打印链表-Python
    上台阶三种实现(斐波那契数列)-Python
    Windows/Linux安装python2.7,pycharm和pandas——《利用Python进行数据分析》
    部署(Django )
    第一个Django模型
    第一个Django Project(创建一个简单的博客)
    几个算法基础
    回文序列—Palindrome
    学习笔记:CentOS7学习之二十:shell脚本的基础
    学习笔记:CentOS7学习之十七: Linux计划任务与日志的管理
  • 原文地址:https://www.cnblogs.com/bj-xiaodao/p/10774661.html
Copyright © 2011-2022 走看看