三：线程池与future

线程池的各项参数说明

https://www.jianshu.com/p/7726c70cdc40

线程池代码使用方式

　　https://blog.csdn.net/achuo/article/details/80623893/

future基本是用来在线程中取得值，线程是在run里面执行的，但是run没有返回值，有时候我门需要取得返回值。但是有一个问题就是，例如我要吃泡面，开水我要现在烧（线程是烧水得到的返回值是开水），面我要在泡开水的时候去商店买。对于程序来说，如果我在卖完泡面回来，开水没好（烧水的线程没结束得不到返回值）如果这个时候程序去执行泡面的操作就会有问题了。

　　最好的解决办法就是，我卖完泡面回来了，水没烧好我就等着（阻塞），等水好了就泡。我们就可以用Callable和Future

　　用法看下

　　

package TestLockStudy;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class FutureCook {
    public static void main(String[] args) {
        //1.购买厨具交给线程（future）
        Callable<chuju> daoCallable = new Callable<chuju>() {

            @Override
            public chuju call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("part 1：开始购买厨具 ");
                Thread.sleep(5000);
                System.out.println("part 1:  买了一把刀");
                return new chuju();
            }
        };
        
        FutureTask<chuju> futureTask = new FutureTask<>(daoCallable);
        new Thread(futureTask).start();
        //2.准备食材
        Callable<shicai> caiCallable=new Callable<shicai>() {

            @Override
            public shicai call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("part 2 : 开始买菜");
                Thread.sleep(2000);
                System.out.println("PART 2 : 买菜结束");
                return new shicai();
            }
        };
        
        FutureTask<shicai> futureTask2 = new FutureTask<>(caiCallable);
        new Thread(futureTask2).start();
        
        //3.开始cook
    }
    
    public void cook() {
        
    }
}

class chuju{
    
    
}

class shicai{
    
}

　　具体看博客：https://www.cnblogs.com/cz123/p/7693064.html

多线程和这个future一起用

线程池与future'

package TestLockStudy;

import java.util.Iterator;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class ThreadPool {
    public void maidao() {
        
    }
    
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(6);
        //新建一个call的线程实例
        ttt t = new ttt();
        //因为这里要传入线程操作，所以要这样把这个传进去
        FutureTask<kaishui> futureTask = new FutureTask<>(t);
        
        newFixedThreadPool.submit(futureTask);
        //不让后面的人进来
        newFixedThreadPool.shutdown();
        
        kaishui kaishui = futureTask.get();
        System.out.println(kaishui);
        
        System.out.println("jieshu");
//        for (int i=0; i<10;i++)
//        {
//            final int j=i;
//                newFixedThreadPool.execute(new Runnable() {
//                @Override
//                public void run() {
//                    // TODO Auto-generated method stub
//                    String name = Thread.currentThread().getName();
//                    System.out.println("执行: "+j+"  线程名字为："+name);
//                }
//            });
//        }
        
    
    
    
    }
}

class ttt implements Callable<kaishui>{

    @Override
    public kaishui call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("开始烧水");
        Thread.sleep(2000);
        System.out.println("水开了");
        return new kaishui();
    }
    
}
class kaishui{
    
}
    
    

具体还是可以看：https://blog.csdn.net/yancychas/article/details/97396366