16. 多线程案例(4)——线程池

╰半夏微凉° 2022-11-05 00:38 326阅读 0赞

## 线程的核心操作 ##

1.execute：把一个任务加到线程池中  
2.shutdown：销毁线程池中的所有线程

## 线程池的组成部分 ##

1.先有一个类，来描述具体线程的要做的工作是啥（借助Runnable接口）  
2.还需要一个数据结构来组织若干个任务，BlockingQueue  
3.需要有一个类，表示工作线程  
4.还需要有一个数据结构，来组织若干个线程，LIst

## 线程池代码 ##

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.BlockingDeque;
    import java.util.concurrent.LinkedBlockingDeque;
    
    public class ThreadDemo25 {
        
    
        //使用当前类表示工作线程
        static class Worker extends Thread{
        
            private int id = 0;
            //每一个Worker线程都需要从任务队列中取任务
            //需要能够获得任务队列的实例
            private BlockingDeque<Runnable> queue = null;
    
            public Worker(BlockingDeque<Runnable> queue,int id){
        
                this.queue = queue;
                this.id = id;
            }
    
            @Override
            public void run() {
        
                try {
        
                       while (!Thread.currentThread().isInterrupted()) {
        
                           Runnable command = queue.take();
                           System.out.println("thread " + id + " running");
                           command.run();
                       }
                    } catch (InterruptedException e) {
        
                        System.out.println("线程被终止");
                    }
                }
        }
    
    
        //本质上是一个生产者消费者模型，调用execute的代码就是生产者，生产了任务（Runnable对象）
        //worker线程就是消费者，消费类队列中的任务
        //交易场所是BlockingQueue
        static class MyThreadPool{
        
            private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();//用来组织若干个任务
            private List<Worker> workers = new ArrayList<>();//用来组织若干个工作进程
            private static final int maxWorkerCount = 10;
    
            //实现execute方法，和shutdown方法
            public void execute(Runnable command) throws InterruptedException {
        
                //使用延时加载的方式创建线程
                //当池子里的线程比较少，新创建线程来作为工作线程
                //如果线程数量较多，就不用创建线程
                if (workers.size() < maxWorkerCount){
        
                    Worker worker = new Worker(queue,workers.size());
                    worker.start();
    
                    workers.add(worker);
                }
                queue.put(command);
            }
    
            //当shutdown结束了就意味着所有线程都结束了
            public void shutdown() throws InterruptedException {
        
                //终止掉所有线程
                for (Worker worker : workers){
        
                    worker.interrupt();
                }
                //还需要等待每个线程执行结束
                for (Worker worker : workers){
        
                    worker.join();
                }
            }
        }
    
        static class Command implements Runnable{
        
            private int num;
            public Command(int num){
        
                this.num = num;
            }
    
            @Override
            public void run() {
        
                System.out.println("正在执行任务" + num);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            MyThreadPool pool = new MyThreadPool();
            for (int i = 0; i < 1000; i++){
        
                pool.execute(new Command(i));
            }
            Thread.sleep(2000);
            pool.shutdown();
            System.out.println("线程池已经被销毁");
        }
    }

部分输出结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20221023/607eb29c24f94545b5d34028582d3bb2.png