Java线程池中哪些事？？

news2024/11/29 1:41:17

需要提前把线程准备好！！创建线程不是直接从系统申请，而是从池子里拿！

等到线程不用了，也是还给池子！！

池子的目的是为了提高效率

线程的创建虽然比进程轻量，但是在频繁创建的情况下，开销也是不可忽略的！！则希望还能进一步提高效率，那么，就需要用到线程池了！！

为啥从池子里拿线程比从系统创建线程更高效？？

原因：从线程池那线程，存粹的用户态操作，从系统创建线程，涉及到用户态和内核态之间的切换，真正的创建，是要在内核态完成的~~

纯用户态操作时间是可控的！

涉及到内核态操作，时间就不太可控了！

标准库里提供了现成的线程池~~

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService pool= Executors.newFixedThreadPool(10);
        //此处并非直接new ExecutorService 对象，而是通过Executors类，里面的静态方法，完成对象的构造
        //工厂模式：创建对象不在new，而是使用一些其他的方法（通常为静态方法），协助我们把对象创建出来
        //Executors.newFixedThreadPool(10)构造一个固定为10线程的线程池
        //Executors.newFixedThreadPool()不设置固定值，按需创建，用完了不会立即销毁，留着以后接着用！
        pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
    }
}

需要大家主注意一下笔者的这些备注~

上述的这些工厂方法，其实都是基于一个类：ThreadPoolExecutor的封装（参数很多，还挺抽象的）

总分：多线程代码，还是挺复杂的，稍微不留点神额，就会有问题！

但是，在Java圈子里，多线程仍然是一个比较主流的并发编程模型~

线程池：从线程池取线程，是属于纯用户态操作，不涉及到和内存的交互！！

ThreadPoolExecutor：标准库提供的四种拒绝策略

ThreadPoolExecutor.AbortPolicy：如果满了，继续添加任务，添加操作直接抛出异常

ThreadPoolExecutor.CallerRunsPolicy：添加的线程自己负责执行这个任务

ThreadPoolExecutor.DiscardOldestPolicy：丢弃最老的任务（最先安排的任务）

ThreadPoolExecutor.DiscardPolicy：丢弃最新的任务

接下来，我们来自己实现一个线程池：

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

class MyThreadPool {
    //手动实现一个线程池
    //阻塞队列
    private BlockingDeque<Runnable> queue=new LinkedBlockingDeque<>();
    public void submit(Runnable runnable) throws InterruptedException{
        queue.put(runnable);
    }

    //此处实现一个固定线程数的线程池
    public MyThreadPool(int n){//n表示线程数量
        for (int i = 0; i < n; i++) {
            Thread t=new Thread(()->{
                try {
                    while (true){
                        //while可确保不停的取任务
                        Runnable runnable=queue.take();
                        runnable.run();
                    }
                }catch (InterruptedException o){
                    o.printStackTrace();
                }
            });
            //启动线程
            t.start();
        }
    }
}


public class Main1 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool=new MyThreadPool(10);//创建线程池
        for (int i = 0; i < 100; i++) {
            int number=i;
            //匿名内部类，而lambad本质就是匿名内部类的简化写法！！

            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello + main");
                }
            });
        }
        Thread.sleep(1000);
    }
}

根据代码的运行结果：