自制笔记 | Java基础——多线程&JUC（持续更新...）

进程：进程是程序的基本执行实体

线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位

并发：在同一时刻，有多个指令在单个CPU上交替进行

并行：在同一时刻，有多个指令在多个CPU上同时执行

实现方式

① 继承Thread类的方式进行实现

public class MyThread extends Thread {
    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "HelloWord");
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        /*
        * 多线程的第一种启动方式：
        *   1.自己定义一个类继承Thread
        *   2.重写run方法
        *   3.创建子类的对象，并启动线程
        * */

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

② 实现Runnable接口的方式进行实现

public class MyRun implements Runnable{
    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            //获取到当前线程的对象
            /*
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + "HelloWorld");
            */
            System.out.println(Thread.currentThread().getName() + "HelloWorld");
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        /*
        * 多线程的第二种启动方式：
        *   1.自己定义一个类实现Runnable接口
        *   2.重写里面的run方法
        *   3.创建自己的类的对象
        *   4.创建一个Thread类的对象，并开启线程
        * */

        //创建MyRun的对象
        //表示多线程要执行的任务
        MyRun mr = new MyRun();

        //创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        //给线程设置名字
        t1.setName("线程1");
        t2.setName("线程2");

        //开启线程
        t1.start();
        t2.start();
    }
}

③ 利用Callable接口和Future接口方式实现

public class MyCallable implements Callable<Integer> {
    //泛型代表返回值的类型
    @Override
    public Integer call() throws Exception {
        //求1~100之间的和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 多线程的第三种实现方式：
        *   特点：可以获取到多线程运行的结果
        *
        *   1.创建一个类MyCallable实现Callable接口
        *   2.重写call（是有返回值的，表示多线程运行的结果）
        *   3.创建MyCallable的对象（表示多线程要执行的任务）
        *   4.创建FutureTask的对象（作用是管理多线程运行的结果）
        *   5.创建Thread的对象，并启动（表示线程）
        * */

        //创建MyCallable的对象（表示多线程要执行的任务）
        MyCallable mc = new MyCallable();

        //创建FutureTask的对象（作用是管理多线程运行的结果）
        FutureTask<Integer> ft = new FutureTask<>(mc);

        //创建Thread的对象
        Thread t1 = new Thread(ft);

        //启动线程
        t1.start();

        //获取多线程运行的结果
        Integer result = ft.get();
        System.out.println(result);
    }
}

三种实现方式对比：

常用成员方法

Thread常见的成员方法：

方法名称	说明
String getname()	返回此线程的名字
void setName(String name)	设置线程的名字（构造方法也可以设置名字）
static Thread currentThread()	获取当前线程的对象
static void sleep(long time)	让线程休眠指定的时间，单位为毫秒
setPriority(int newPriority)	设置线程的优先级
final int getPriority	获取线程的优先级
final void setDaemon(boolean on)	设置为守护线程
public static void yield()	出让线程 / 礼让线程
public static void join()	插入线程 / 插队线程

getName方法细节：
如果我们没有给线程设置名字，线程也是有默认的名字的，格式：Thread-X(X序号，从0开始)

setName方法细节：
如果我们要给线程设置名字，可以用set方法进行设置，也可以调用Thread类的构造方法设置

currentThread方法细节：
在JVM虚拟机启动之后，会自动地启动多条线程，其中有一条线程就叫做main线程，他的作用就是去调用main方法，并执行里面的代码

sleep方法细节：
哪条线程执行到这个方法，那么这条线程就会在这里停留对应的时间

优先级：Java采取抢占式调度（随机性），线程优先级（1~10，默认是5）越大，抢到CPU的概率就越大

setDaemon方法细节：当其他的非守护线程执行完毕之后，守护线程会陆续结束（守护线程并不会马上结束，而是会有一定的延迟时间）

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + i);
        }
    }
}

public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName() + i);
        }
    }
}

public class Test5 {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        //把第二个线程设置为守护线程（备胎线程）
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}

yield方法细节：在执行到yield方法时，线程会出让当前的CPU执行权，但注意，此线程还是有可能在下次也争夺到CPU执行权

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName() + i);
            //表示出让当前CPU的执行权
            Thread.yield();
        }
    }
}

public class Test6 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("飞机");
        t2.setName("坦克");

        t1.start();
        t2.start();
    }
}

join方法细节：会把执行这个方法的线程插入到当前线程之前，直到该线程结束后，当前线程才能继续执行下面的代码

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName() + i);
        }
    }
}

public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.setName("土豆");
        t.start();

        //表示把t这个线程，插入到当前线程之前
        //t：土豆
        //当前线程：main线程
        t.join();

        for (int i = 1; i <= 10; i++) {
            System.out.println("main线程" + i);
        }
    }
}

线程的生命周期：

安全问题

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口，请设计一个程序模拟该电影院卖票

public class MyThread extends Thread{
    //表示这个类所有的对象，都共享ticket数据
    static int ticket = 0;

    @Override
    public void run() {
        while(true) {
            if(ticket < 100) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket++;
                System.out.println(getName() + "正在卖第" + ticket + "张票");
            }
            else {
                break;
            }
        }
    }
}

public class Test8 {
    public static void main(String[] args) {
        //创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        //起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        //开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

上面的代码会引发两个安全问题：

① 相同的票出现了多次
② 出现了超出范围的票

原因：线程执行时，有随机性。线程在执行代码时，随时都有可能被其他线程抢断，因此若线程在执行完14行后被其他线程抢占，可能会导致相同的票出现；在执行14行之前被抢占，可能会导致出现超出范围的票

解决方法：同步代码块（把操作共享数据的代码锁起来）

格式：

synchronized (锁) {
    操作共享数据的代码
}

特点1：锁默认打开，有一个线程进去了，锁自动关闭
特点2：里面的代码全部执行完毕，线程出来，锁自动打开

更改MyThread类：

public class MyThread extends Thread{
    //表示这个类所有的对象，都共享ticket数据
    static int ticket = 0;

    //锁对象，可以是任意对象，但一定要是唯一的（static）
    static Object obj = new Object();

    @Override
    public void run() {
        while(true) {
            //同步代码块
            synchronized (obj) {
                if(ticket < 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                }
                else {
                    break;
                }
            }
        }
    }
}

注意：锁对象一定要是唯一的，一般使用当前类的字节码文件对象，例如MyThread.class

同步方法：

就是把synchronized关键字加到方法上

格式：

修饰符 synchronized 返回值类型 方法名(方法参数) {...}

特点1：同步方法是锁住方法里面所有的代码
特点2：锁对象不能自己指定，是Java已经规定好的（非静态：this，静态：当前类的字节码文件对象）

示例：

public class MyRunnable implements Runnable{
    int ticket = 0;

    @Override
    public void run() {
        //1.循环
        while(true) {
            //2.同步代码块（同步方法）
            if (method()) break;
        }
    }

    //this
    private synchronized boolean method() {
        //3.判断共享数据是否到了末尾，如果到了末尾
        if(ticket == 100) {
            return true;
        }
        //4.判断共享数据是否到了末尾，如果没到末尾
        else {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "在卖第" + ticket + "张票！");
        }
        return false;
    }
}

锁：

Lock锁实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法：
void lock()：手动获得锁
void unlock：手动释放锁

Lock是接口，不能直接实例化，这里采用它的实现类ReentrantLock来实例化，ReentrantLock的构造方法：Reentrantlock()

示例：

public class MyThread extends Thread{
    static int ticket = 0;

    static Lock lock = new ReentrantLock(); //static保证锁的一致性

    public void run() {
        while(true) {
            lock.lock();
            try {
                if(ticket < 100) {
                    Thread.sleep(10);
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                }
                else {
                    break;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
            //如果lock.unlock()写在这个位置，会导致线程没有释放锁而退出循环，进而导致其他线程被永久阻塞，因此使用try...catch...finally的方式保证unlock一定会被执行
        }
    }
}

死锁：

锁的嵌套可能会导致死锁的发生

示例：

public class MyThread extends Thread{
    static Object objA = new Object();
    static Object objB = new Object();

    @Override
    public void run() {
        while(true) {
            if("线程A".equals(getName())) {
                synchronized (objA) {
                    System.out.println("线程A拿到了A锁，准备拿B锁");
                    synchronized (objB) {
                        System.out.println("线程A拿到了B锁，顺利执行完一轮");
                    }
                }
            }
            else if("线程B".equals(getName())) {
                if("线程B".equals(getName())) {
                    synchronized (objB) {
                        System.out.println("线程B拿到了B锁，准备拿A锁");
                        synchronized (objA) {
                            System.out.println("线程B拿到了A锁，顺利执行完一轮");
                        }
                    }
                }
            }
        }
    }
}

等待唤醒机制

生产者消费者（等待唤醒机制）模式是一个十分经典的多线程协作模式

思路：

常见方法：

方法名称	说明
void wait()	当前线程等待，直到被其他线程唤醒
void notify()	随机唤醒单个线程
void notifyAll()	唤醒所有线程

第一种实现方式：

桌子：

public class Desk {
    /*
    * 作用：控制生产者和消费者的执行
    * */

    //是否有面条  0：没有面条  1：有面条
    public static int foodFlag = 0;

    //总个数
    public static int count = 10;

    //锁对象
    public static Object lock = new Object();
}

生产者：

public class Cook extends Thread{
    @Override
    public void run() {
        while(true) {
            synchronized (Desk.lock) {
                if(Desk.count == 0) {
                    break;
                }
                else {
                    //先判断桌子上是否有面条
                    if(Desk.foodFlag == 1) {
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    else {
                        //如果没有，就制作食物
                        System.out.println("厨师做了一碗面条");
                        //修改桌子状态
                        Desk.foodFlag = 1;
                        //唤醒吃货
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

消费者：

public class Foodie extends Thread{
    @Override
    public void run() {
        /*
        * 1.循环
        * 2.同步代码块
        * 3.判断共享数据是否到了末尾（到了末尾）
        * 4.判断共享数据是否到了末尾（没到末尾）
        * */

        while(true) {
            synchronized (Desk.lock) {
                if(Desk.count == 0) {
                    break;
                }
                else {
                    //先判断桌子上是否有面条
                    if(Desk.foodFlag == 0) {
                        //如果没有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    else {
                        //把吃的总数减1
                        Desk.count--;
                        //开吃
                        System.out.println("吃货在吃面条，还能再吃" + Desk.count + "碗面条");
                        //吃完之后，唤醒厨师
                        Desk.lock.notifyAll();
                        //修改桌子的状态
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}

主程序：

public class Test12 {
    public static void main(String[] args) {
        Cook c = new Cook();
        Foodie f = new Foodie();

        c.setName("厨师");
        f.setName("吃货");

        c.start();
        f.start();
    }
}

第二种实现方式（阻塞队列）：

阻塞队列的继承结构：

生产者：

public class Cook extends Thread{

    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while(true) {
            //不断地把面条放到阻塞队列当中
            try {
                queue.put("面条"); //代码底层会对阻塞队列加锁并释放锁
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

消费者：

public class Foodie extends Thread{

    ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while(true) {
            //不断地从阻塞队列中获取面条
            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

主程序：

public class Test13 {
    public static void main(String[] args) {
        /*
        * 细节：生产者和消费者必须使用同一个阻塞队列
        * */

        //1.创建阻塞队列的对象
        ArrayBlockingQueue queue = new ArrayBlockingQueue(1);

        //2.创建线程的对象，并把阻塞队列传递过去
        Cook c = new Cook(queue);
        Foodie f = new Foodie(queue);

        //3.开启线程
        c.start();
        f.start();
    }
}

线程的状态

Java虚拟机中，是没有定义运行状态的，因为当线程抢到CPU的执行权后，虚拟机会把线程交给操作系统管理，而自己则不管理这个线程

线程池

以前写多线程的弊端：
① 用到线程的时候就创建
② 用完之后线程消失
这样会导致时间和资源的浪费

线程池主要核心原理：

① 创建一个池子，池子中是空的
② 提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子，下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可
③ 但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程（线程池达到数量上限），任务就会排队等待

代码实现：

① 创建线程池

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象

方法名称	说明
public static ExecutorService newCachedThreadPool()	创建一个没有上限的线程池
public static ExecutorService newFixedThreadPool(int nThreads)	创建有上限的线程池

② 提交任务
③ 所有的任务全部执行完毕，关闭线程池

示例：

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

public static void main(String[] args) throws InterruptedException {
    //1.获取线程池对象
    ExecutorService pool1 = Executors.newCachedThreadPool();

    //2.提交任务

    //展示线程的复用
    pool1.submit(new MyRunnable());
    Thread.sleep(1000);

    pool1.submit(new MyRunnable());
    Thread.sleep(1000);

    pool1.submit(new MyRunnable());
    Thread.sleep(1000);

    pool1.submit(new MyRunnable());
    Thread.sleep(1000);

    pool1.submit(new MyRunnable());
    Thread.sleep(1000);

    pool1.submit(new MyRunnable());
    Thread.sleep(1000);

    //3.销毁线程池
    //pool1.shutdown();
}

自定义线程池：

核心参数：

① 核心线程数量（不能小于0）
② 线程池中最大线程的数量（最大数量 >= 核心线程数量）
③ 空闲线程最大存活时间（值）（不能小于0），表示除了核心线程以外的线程空闲多长时间会被销毁
④ 空闲时间（单位）（用TimeUnit指定）
⑤ 阻塞队列（不能为null）
⑥ 创建线程的方式（不能为null）
⑦ 要执行的任务过多时的解决方案（不能为null）

细节：

① 当核心线程满载时，再提交任务就会排队
② 只有核心线程都在忙，且队伍已经排满了，才会创建临时线程
③ 先提交的任务不一定先执行，例如图中的任务7 8 9先于任务4 5 6执行
④ 若核心线程，队伍，临时线程均已满载，则后面到来的任务会触发任务拒绝策略

任务拒绝策略：

任务拒绝策略	说明
ThreadPoolExecutor.AbortPolicy	**默认策略：**丢弃任务并抛出RejectedExecutionException异常
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	调用任务的run()方法绕过线程池直接执行

示例：

ThreadPoolExecutor pool = new ThreadPoolExecutor(
        3, //核心线程数量，不能小于0
        6, //最大线程数，不能小于0，最大数量 >= 核心线程数量
        60, //空闲线程最大存活时间
        TimeUnit.SECONDS, //时间单位
        new ArrayBlockingQueue<>(3), //任务队列
        Executors.defaultThreadFactory(), //创建线程工厂
        new ThreadPoolExecutor.AbortPolicy() //任务的拒绝策略
);

线程池的合适大小：

CPU密集型运算：
$$最大并行数+1$$
I/O密集型运算：
$$最大并行数\cdot 期望CPU利用率\cdot \frac{总时间(CPU计算时间+等待时间)}{CPU计算时间}$$
这里的最大并行数指的是CPU最多并行使用线程的数量，例如4核8线程中最大并行数为8

任务拒绝策略	说明
ThreadPoolExecutor.AbortPolicy	**默认策略：**丢弃任务并抛出RejectedExecutionException异常
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	调用任务的run()方法绕过线程池直接执行

示例：

ThreadPoolExecutor pool = new ThreadPoolExecutor(
        3, //核心线程数量，不能小于0
        6, //最大线程数，不能小于0，最大数量 >= 核心线程数量
        60, //空闲线程最大存活时间
        TimeUnit.SECONDS, //时间单位
        new ArrayBlockingQueue<>(3), //任务队列
        Executors.defaultThreadFactory(), //创建线程工厂
        new ThreadPoolExecutor.AbortPolicy() //任务的拒绝策略
);

线程池的合适大小：

CPU密集型运算：
$$最大并行数+1$$
I/O密集型运算：
$$最大并行数\cdot 期望CPU利用率\cdot \frac{总时间(CPU计算时间+等待时间)}{CPU计算时间}$$
这里的最大并行数指的是CPU最多并行使用线程的数量，例如4核8线程中最大并行数为8