java中的线程通讯和线程池，Callable任务

线程通讯：
在多线程中，某个线程进入“等待状态”时，需要某个线程来唤醒

等待方法：
wait()//无线等待

wait(long 毫秒)//计时等待

注意，调用wait方法，会自动释放掉锁资源

处于wait状态只能由其他线程唤醒

唤醒方法：
notify();//唤醒处于“等待状态”的任意一个线程，和notify使用相同锁对象的线程

notifyAll();//唤醒处于“等待状态”的所有线程

注意，调用notify(),notifyAll()方法，不会自动释放掉锁资源

使用细节：

等待和唤醒的方法，都要使用锁对象调用（需要在同步代码块中使用）

等待和唤醒方法都应该使用相同的锁对象调用

消费者，生产者模型：

//共享资源
public class Resource {
    static public int number=0;
}

public class test2 {
    public static void main(String[] args) {
        Object lock=new Object();

        //创建消费者线程
        new Thread(new Runnable() {
            @Override
            public void run() {

                while (true) {
                    synchronized (lock) {
                        if (Resource.number >= 3) {
                            System.out.println("这有足够多的食物");
                            try {
                                lock.wait();//阻塞并释放锁
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        } else {
                            Resource.number++;//，一开时number=0,先++再打印
                            System.out.println("[p]:" + Resource.number);
                            lock.notify();//唤醒处于等待状态的线程，且不会释放锁
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                }

            }
        }).start();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (lock) {
                        if(Resource.number==0)
                        {
                            System.out.println("这没有足够的资源");
                            try {
                                lock.wait();//阻塞的同时会释放掉锁
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        else {
                            System.out.println("[c]"+Resource.number);//先打印，再--
                            Resource.number--;

                            lock.notify();//唤醒生产者线程，生产者如果没有处于等待，就没事
                            //只能唤醒别的线程
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }

                        }
                    }
                }
            }
        };
        new Thread(task).start();
    }

}

线程池：
如何获得线程池对象：

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象 

计算密集型任务：核心线程数：cpu数+1

IO密集型任务：核心线程数：cpu数*2

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

参数一：  corePoolSize：指定线程池的核心线程的数量

参数二：maximumPoolSize：指定线程池的最大线程数量

参数三： long keepAliveTime：指定临时线程的存活时间（没有事情干）

参数四：unit：指定临时线程的存活时间单位（分，秒，天）

参数五：workQueue：指定线程池的任务队列

参数六：threadFactory:指定线程池的线程工厂

参数七： handler：指定线程池的任务拒接策略

例如：

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 8, TimeUnit.MINUTES,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),//  // Executors.defaultThreadFactory()获取默认的线程池工厂
                new ThreadPoolExecutor.AbortPolicy());

临时线程什么时候创建：

新任务提交时发现核心线程都在忙，任务对列也满了，并且还可以创建临时线程

什么时候拒绝新任务：
核心线程和临时线程都满了，任务队列也满了 

一个任务类：

public class Task1 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"输出yyyy");
        try{
        Thread.sleep(1000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

public class test {
    public static void main(String[] args) {
        //创建一个线程池对象
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 8, TimeUnit.MINUTES,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),//  // Executors.defaultThreadFactory()获取默认的线程池工厂
                new ThreadPoolExecutor.AbortPolicy());

        //添加任务
        threadPoolExecutor.execute(new Task1());//线程池会自动创建一个线程，自动处理任务

        threadPoolExecutor.shutdown();//等待线程池所有任务执行完后关闭线程池
        threadPoolExecutor.shutdownNow();//立即关闭线程池
    }
}

方式二：使用Executors工具类

public static ExecutorService newFixedThreadPool(int nThreads)

创建固定线程数量的线程池，如果某个线程因为异常关闭，那么线程池会创建出一个新的线程

public static ExecutorService newSingleThreadExecutor()

创建只有一个线程的线程池， 如果这个线程因为异常关闭，那么线程池会创建出一个新的线程

Callable任务：

 Interface Callable<V>

Callable支持结果返回，Runnable不行

Callable可以抛出异常，Runnable不行

Callable任务处理使用步骤：
1：创建线程池

2：定义Callable任务

3：创建Callable任务，提交任务给线程池

4：获取执行结果

public class test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程池对象
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //创建一个Callable类型的任务类

        Callable<Integer>callable=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum=0;
                for(int i=0;i<10;i++)
                {
                    sum+=i;
                }
                return sum;
            }

        };
        //交给线程池处理（submit()方法），并获取返回值
        Future<Integer> submit = executorService.submit(callable);
        System.out.println(submit.get());//通过get方法获取返回值

    }

}