JAVA基础高级复习(七)生命周期图_线程池_Callable方法

 wait(会释放锁)必须等其他线程notify才会结束阻塞,结束之后,所有线程抢夺资源,抢到的执行,抢不到的进入同步阻塞;

 缓存线程池

可变线程池 

 

 ---------就是:(一)如果我要用线程池,我就实现callable接口,然后用executor.new得到一个线程池,用.submit方法加入到线程池里去;

(二)利用Futuretask构造方法

callable

 shutdown会把排队任务执行完;shutdownNow不执行排队任务;

------------------------------------

call是有返回值,没有形参;有泛型,默认返回obj;

 

接口Future,表示异步计算出的结果;

通过API_get方法会等待计算结束后返回;(也就是堵塞方法,堵塞等待这个结果的方法的这个线程吧)

 --

利用Futuretask构造方法

FutureTask(Callable c)

 

package _016day;

import java.util.concurrent.*;

/**
 * @author looper
 * @
 **/
public class ThreadPoolTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        pool.submit(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "+"+i);
            }
        });
        pool.submit(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"++"+i);
            }
        });
        pool.submit(()->1+1);
//利用线程池submit
        ExecutorService pool1 = Executors.newFixedThreadPool(2);
        Future future = pool1.submit(new Mythread());
        Object o = future.get();
        //
        ExecutorService spool = Executors.newSingleThreadExecutor();
        Future future1 = spool.submit(new Mythread());
        future1.get();
        //返回的一个未来任务,可以get,
        Mythread mcall = new Mythread();
        FutureTask ft = new FutureTask<>(mcall);
        ft.get();
        Thread t1 = new Thread(ft);
        t1.start();
        //和runnable接口的不同在哪里//如果是runnable  就是多了一步放到future里了可以get
        // 思考公共资源的callable;一样的使用,就是多一步get方法;
        Mythread2 mrun = new Mythread2();
        Thread t2 = new Thread(mrun);


    }
}
class Mythread implements Callable{

    @Override
    public Object call() throws Exception {
        return null;
    }
}
class Mythread2 implements Runnable{
    @Override
    public void run() {

    }
}