线程池笔记

线程的状态

 

小结：

虚拟机中线程的六种状态：

新建状态（NEW） → 创建线程对象

就绪状态（RUNNABLE）→ start方法

阻塞状态（BLOCKED）→无法获得锁对象

等待状态（WAITING) → wait方法

计时等待（TIMED_WAITING） → sleep方法

结束状态（TERMINATED)→全部代码允许完毕

线程池-基本原理

之前写代码的弊端：

1.用到线程的时候就创建

2.用完之后线程消失

1.创建一个池子

2.当有任务需要执行时，才会创建线程对象，当任务执行完毕，线程对象归还给池子

线程池-Executors默认线程池

1.创建一个池子，池子中是空的 →创建Executors中的静态方法

2.有任务需要执行时，创建线程对象。任务执行完毕，线程uix归还给池子。 → submit方法 池子会自动地帮我们创建对象，任务执行完毕，也会自动把线程对象归还池子

3.所有的任务全部执行完毕，关闭连接池 → shutdown方法

package test14;

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

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        Thread.sleep(2000);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.shutdown();
    }
}

线程池-Executors创建指定上限的线程池

可以利用断点查看程序运行时的各个参数

 线程池里面有2个

package test14;

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

public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //参数nThreads不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0
                executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
        System.out.println(pool.getPoolSize());//2  打印当前线程数

        //executorService.shutdown(); //关闭线程池
    }
}

 

ThreadPooIExecutor

故事中的核心元素

核心元素一：正式员工数量 → 核心线程数量

核心元素二：餐厅最大员工数 → 线程池中最大线程的数量

核心元素三：临时员工空闲多长时间被辞退（值）→ 空闲时间（值）

核心元素四：临时员工空闲多长时间被辞退（单位）→空闲时间（单位）

核心元素五：排队的客户 → 阻塞队列

核心元素六：从哪里招人 → 创建线程的方式

核心元素七：当排队人数过多，超出顾客请下次再来（拒绝服务）→ 要执行的任务过多时的解决方案

package test14;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
    public static void main(String[] args) {
/*      参数一：核心线程数量
        参数二：最大线程数
        参数三：空闲线程最大存活时间
        参数四：时间单位
        参数五：任务队列
        参数六：创建线程工厂
        参数七：任务的拒绝策略    */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
    }
}

//*************************分隔符

package test14;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "在执行了");
    }
}

创建线程池对象

参数一： 核心线程数量 → 不能小于0

参数二：最大线程数 → 不能小于等于0，最大数量>=核心线程数量

参数三：空闲线程最大存活时间 → 不能小于0

参数四：时间单位 → 时间单位

参数五：任务队列→不能为null

参数六：创建线程工厂 → 不能为null

参数七： → 不能为null

参数详解

package test14;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo4 {
    public static void main(String[] args) {
/*      参数一：核心线程数量
        参数二：最大线程数
        参数三：空闲线程最大存活时间
        参数四：时间单位
        参数五：任务队列 --- 让任务再队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
        参数六：创建线程工厂 --- 按照默认的方式创建线程对象
        参数七：任务的拒绝策略 --- 什么时候拒绝任务？  当提交的任务 > 池子中最大线程数量
        如何拒绝？   */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0 ; i < 15 ; i ++) {
            pool.submit(new MyRunnable());
        }


        pool.shutdown();
    }
}

非默认任务拒绝策略

ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。是默认的策略

ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常，这是不推荐的做法。

ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中

ThreadPoolExecutor.CallerRunsPolicy：调用任务的run()方法绕过线程池直接执行

package test14;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo5 {
    public static void main(String[] args) {
/*      参数一：核心线程数量
        参数二：最大线程数
        参数三：空闲线程最大存活时间
        参数四：时间单位
        参数五：任务队列 --- 让任务再队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
        参数六：创建线程工厂 --- 按照默认的方式创建线程对象
        参数七：任务的拒绝策略 --- 什么时候拒绝任务？  当提交的任务 > 池子中最大线程数量
        如何拒绝？   */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 1 ; i < 5 ; i ++) {
            int y = i;
            pool.submit(()->{

                System.out.println(Thread.currentThread().
                        getName() + "---" + y);
            });
        }


        pool.shutdown();
    }
}

package test14;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo6 {
    public static void main(String[] args) {
/*      参数一：核心线程数量
        参数二：最大线程数
        参数三：空闲线程最大存活时间
        参数四：时间单位
        参数五：任务队列 --- 让任务再队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
        参数六：创建线程工厂 --- 按照默认的方式创建线程对象
        参数七：任务的拒绝策略 --- 什么时候拒绝任务？  当提交的任务 > 池子中最大线程数量
        如何拒绝？   */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 1 ; i < 10 ; i ++) {
            int y = i;
            pool.submit(()->{

                System.out.println(Thread.currentThread().
                        getName() + "---" + y);
            });
        }


        pool.shutdown();
    }
}