Java多线程之线程池（合理分配资源）

package bao;
import java.util.concurrent.*;
public class Test {
    public static void main(String[] args) {
        /* //一、1.自己定义一个线程池对象----多态的写法
        * 3个核心员工(3个核心线程)
        * 5个总员工，那就是临时工是2个（总线程5个）
        * 6s,TimeUnit.SECONDS----临时工没事干就被销毁辞退了
        * 员工最多只能5个
        * Executors.defaultThreadFactory()-----默认线程工厂
        *new ThreadPoolExecutor.AbortPolicy()-----拒绝别人
        * */
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //5.new创建线程
        Runnable target = new MyRunnable();
        //线程多少来自于上面自定义
        //因为线程方法都一样。调用有可能一下子就调用线程4-3-1了，那剩余的有可能会分配到任务，有可能闲着
        pool.execute(target);//核心线程1
        pool.execute(target);//核心线程2
        pool.execute(target);//核心线程3
        //创建临时线程（线程名字都一样，5个不一定哪个是核心，哪个是临时，分辨不出来）
        pool.execute(target);//线程4
        pool.execute(target);//线程5
        //为什么一些超过5条线程还能运行不报错呢？比如线程池里面只有5个位置，但是看着这么多线程都在，以为可以调用超过5个，一旦调用超过了5个就会报错
        //关闭线程（几乎不会用到，了解了就好了）
        //pool.shutdownNow();立即强制关掉,即使任务没有完成也会被关掉，会丢失任务
        //pool.shutdown();等待任务完成后再关闭，相对柔和
    }
}
//二、创建线程对象类
//2.创建线程类
class MyRunnable implements Runnable{
    //3.重写run方法
    @Override
    public void run() {
        //4.定义线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出了：月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务
        }
    }
}

package bao;
import java.util.concurrent.*;
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //二、4.自定义线程的规则(详情看上一题)
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //5.把任务给线程池
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        Future<String> f5 = pool.submit(new MyCallable(500));
        //6.输出结果
        System.out.println(f1.get());//有异常直接抛出就好了
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());
    }
}
//一、1.创建线程任务类Callable
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n=n;
    }
//2.重写Call方法
    @Override
    public String call() throws Exception {
//3.写线程要执行的具体任务代码
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行1-"+n+"的和是"+sum;
    }
}

package bao;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test {
    public static void main(String[] args) {
        //二、5.创建固定线程池数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);//这里固定线程池里面只能有3个线程
        //6.创建线程
        pool.execute(new MyRunnable());//线程1
        pool.execute(new MyRunnable());//线程2
        pool.execute(new MyRunnable());//线程3
        //创建多余的线程也不要了，看都不看，就算上面的线程睡眠了
    }
}
//一、1.创建线程对象类
//2.创建线程类
class MyRunnable implements Runnable{
    //3.重写run方法
    @Override
    public void run() {
        //4.定义线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出了：月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务
        }
    }
}