多线程、线程池

线程状态

线程总共有5大状态：
新建状态 -> 就绪状态 -> 运行状态 -> 阻塞状态 -> 死亡状态
新建状态：新建线程对象，并没有调用start()方法之间
就绪状态：调用了start()方法之后线程进入就绪状态，但是不是立马执行。
运行状态：线程被设置为当前线程，开始执行run()方法。就是线程进入运行状态
阻塞状态：线程被暂停，比如调用sleep()方法后线程就进入阻塞状态。
死亡状态：线程执行结束。

阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）

线程相关的方法
wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁。
sleep()：使一个正在运行的线程处于睡眠状态。
notify()：唤醒一个处于等待状态的线程。
notifyAll()：唤醒所有处于等待状态的线程。

synchronized与Lock的区别

synchronized是java内置关键字，在jvm层面，Lock是个java类

synchronized是一种悲观锁
Lock是一种乐观锁

乐观锁： 数据被访问，认为用户不会去修改数据，都不去上锁。
悲观锁： 数据被访问，认为用户会去修改数据，都上锁。

线程池（可以降低资源的消耗，提高系统的性能。避免多次创建和多次销毁。）

功能线程池

定长线程池（只有核心线程,线程数量固定,执行完立即回收）

定时线程池（核心线程数量固定,非核心线程数量无限,执行完闲置10ms后回收）

可缓存线程池（无核心线程,非核心线程数量无限,执行完闲置60s后回收）

单线程化线程池（只有1个核心线程,无非核心线程,执行完立即回收）

1、定长线程池（FixedThreadPool）

特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：控制线程最大并发数。

public class Test01 {
    public static void main(String[] args) {
//      1、创建定长线程池对象   设置线程池线程数量固定为3
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
//      2、创建Runnable类对象   执行的任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("定长线程池");
            }
        };
//      3、向线程池提交任务
        fixedThreadPool.execute(runnable);
//      4、停止任务，正在执行的任务会继续执行下去。
        fixedThreadPool.shutdown();
//      5、停止任务，正在执行的任务也继续停止。
        fixedThreadPool.shutdownNow();
    }
}

2、定时线程池（ScheduledThreadPool ）

特点：核心线程数量固定，非核心线程数量无限，执行完闲置10ms后回收，任务队列为延时阻塞队列。
应用场景：执行定时或周期性的任务。

public class Test02 {
    public static void main(String[] args) {
//      1、创建 定时线程池对象 设置线程池 线程数量
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
//      2、创建Runnable类对象 执行任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("定时线程池");
            }
        };
//      3、向线程池提交任务
//      延迟1S后执行任务
        scheduledThreadPool.schedule(runnable,1, TimeUnit.SECONDS);
//      延迟10ms后，每隔1000ms执行任务
        scheduledThreadPool.scheduleWithFixedDelay(runnable,10,1000,TimeUnit.MILLISECONDS); 
    }
}

3、可缓存线程池（CachedThreadPool）

特点：无核心线程，非核心线程数量无限，执行完闲置60S后回收，任务队列为不存储元素的阻塞队列。
应用场景：执行大量、耗时少的任务。

public class Test03 {
    public static void main(String[] args) {
//      1、创建可缓存线程池对象
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
//      2、创建Runnable类线程对象 执行任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("可缓存线程池");
            }
        };
//      3、向线程池提交任务
        cachedThreadPool.execute(runnable);
    }
}

4、单线程化线程池（SingleThreadExecutor）

特点：只有1个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：不适合并发单可能引起IO阻塞性及影响UI线程响应的操作、数据库操作、文件操作等。

public class Test04 {
    public static void main(String[] args) {
//      1、创建单线程化线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
//      2、创建Runnable类线程对象 执行任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("单线程化线程池");
            }
        };
//      3、向线程池提交任务
        scheduledExecutorService.execute(runnable);
    }
}