[Java知识库]Java多线程与并发以及线程池四种方式详细图解

前言

Java多线程是很重要的一个知识点，随着业务量和数据的增加，在以后企业多线程的运用也是很多的，并且在面试中，多线程也是一个必考的高阶知识点之一。

什么是多线程？

线程与进程

进程：

• 进程是程序在计算机上的一次执行活动，当你运行一个程序，你就启动了一个进程，例如运行QQ、微信，系统就会创建进程来处理我们日常的操作，打开任务管理器，进程列表里就有QQ和Wechat的.exe的运行程序如图：

• 程序是计算机指令的集合，它以文件的形式存储在磁盘上，即程序是静态的代码。

线程：

• 进程可以进一步细化为线程，是一个程序内部的执行路径，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
• 线程是cpu调度和执行的单位，每个线程拥有独立的运行栈和PC(程序计数器)

线程调度

分时调度

• 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

• 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，
  Java使用的为抢占式调度
• CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，
  只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时
  刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使
  用率更高。

并行与并发

• 并发：指两个或多个事件在同一个时间段内发生，单核cpu运行多线程时，时间片进行很快的切换。线程轮流执行cpu。
• 并行：指两个或多个事件在同一时刻发生（同时发生），多核cpu运行 多线程时，真正的在同一时刻运行。
  

同步与异步

• 同步：排队执行 , 效率低但是安全。
• 异步：同时执行 , 效率高但是数据不安全。
  

为什么需要多线程？

多线程能实现的都可以用单线程来完成，那单线程能完成，为什么java要引入多线程呢？

简而言之多线程的好处：

1. 通过充分利用CPU效率，提高程序运行效率。
2. 发挥多核CPU的优势，提高CPU利用率。
3. 防止阻塞，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。
4. 便于建模，例如任务模块多，单线程只能建立整个程序模型比较麻烦，但是如果把大任务模块分为任务A,B,C，分别建立程序模型，通过多线程运行，效率很高很多。

多线程的三种实现方式

1. 继承Thread类(将任务和线程合并在一起)

测试实例：

MyThread类继承Thread，重写run()方法，实现多线程里面的方法。

public class MyThread extends Thread {

    private String letter;

    public MyThread(String letter) {
        this.letter = letter;
    }

    @Override
    public void run() {
        //这就是新的一条执行路径
        //这个路径执行的方式不是通过run()方法，是通过thread对象的start()来启动任务
        for (int i = 0; i < 5; i++) {
            System.out.println("我是分支线程 " + letter + " === " + i);
        }
    }
}

MyThreadTest类测试多线程

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread("AAAAA");
        MyThread myThread2 = new MyThread("BBBBB");
        myThread1.start();
        myThread2.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("这是主线程 CCCCC === " + i);
        }
    }
}

测试结果:

这是主线程CCCCC === 0
这是主线程CCCCC === 1
这是主线程CCCCC === 2
这是主线程CCCCC === 3
这是主线程CCCCC === 4
我是分支线程 AAAAA === 0
我是分支线程 AAAAA === 1
我是分支线程 AAAAA === 2
我是分支线程 BBBBB === 0
我是分支线程 AAAAA === 3
我是分支线程 AAAAA === 4
我是分支线程 BBBBB === 1
我是分支线程 BBBBB === 2
我是分支线程 BBBBB === 3
我是分支线程 BBBBB === 4

Process finished with exit code 0

再运行一次:

这是主线程 CCCCC === 0
这是主线程 CCCCC === 1
这是主线程 CCCCC === 2
这是主线程 CCCCC === 3
这是主线程 CCCCC === 4
我是分支线程 AAAAA === 0
我是分支线程 BBBBB === 0
我是分支线程 BBBBB === 1
我是分支线程 AAAAA === 1
我是分支线程 BBBBB === 2
我是分支线程 AAAAA === 2
我是分支线程 BBBBB === 3
我是分支线程 AAAAA === 3
我是分支线程 BBBBB === 4
我是分支线程 AAAAA === 4

Process finished with exit code 0

可以看到有时候运行输出的结果是不一样的

程序在启动的时候，Java虚拟机就已经启动了一个主线程来运行main函数，在调用到myThread1和myThread2 方法时，就相当于有三个线程在同时工作了，这就是多线程的模式。
可以看到一般情况下主线程都是能先抢占的，因为主线程的优先级是高于分支线程的，所以优先让优先级高的线程使用 CPU。
在分支线程myThread1和myThread2执行中，两个分支线程优先级相同，所以是随机的，也可以认为是随机抢占的，线程中是有sleep()方法的，调用sleep方法进入阻塞状态然后CPU资源会释放，就是为了不让优先级先相同的线程霸占所有CPU资源，会留一定资源给其他线程执行，所以看到子线程是交替随机在执行的。

2. 实现Runnable接口(将任务和线程分开了)

测试实例：
MyRunnable类实现Runnable接口，重写run()方法，实现多线程里面的方法。

public class MyRunnable implements Runnable{

    private String letter;

    public MyRunnable(String letter) {
        this.letter = letter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("我是分支线程 " + letter + " === " + i);
        }
    }
}

MyRunnableTest类测试Runnable实现多线程

public class MyRunnableTest {
    public static void main(String[] args) {
        //实现Runnable
        //1. 创建一个任务对象
        MyRunnable myRunnable1 = new MyRunnable("AAAAA");
        MyRunnable myRunnable2 = new MyRunnable("BBBBB");
        //2. 创建一个线程，并为其分配一个任务
        Thread thread1 = new Thread(myRunnable1);
        Thread thread2 = new Thread(myRunnable2);
        //3. 执行这个线程
        thread1.start();
        thread2.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("这是主线程 CCCCC === " + i);
        }
    }
}

测试结果：

这是主线程 CCCCC === 0
这是主线程 CCCCC === 1
这是主线程 CCCCC === 2
这是主线程 CCCCC === 3
这是主线程 CCCCC === 4
我是分支线程 AAAAA === 0
我是分支线程 BBBBB === 0
我是分支线程 AAAAA === 1
我是分支线程 BBBBB === 1
我是分支线程 AAAAA === 2
我是分支线程 BBBBB === 2
我是分支线程 AAAAA === 3
我是分支线程 BBBBB === 3
我是分支线程 AAAAA === 4
我是分支线程 BBBBB === 4

Process finished with exit code 0

整体和继承Thread差别不大，因为在Thread类中也是继承的Runnable接口。

MyRunnable类通过实现Runnable接口，重写了run()方法，使得该类有了多线程类的特征。所有的多线程代码都在run()方法里面。Thread类也是实现了Runnable接口的类。
在实现Runnable的过程中需要先创建任务对象，再创建线程分配任务，最后同样需要调用Thread对象的start()方法来运行多线程代码

Thread类和Runnable接口的区别

继承Thread类不适合资源共享，不能被多个线程共享，但是实现Runnable接口可以实现资源共享，实现代码和数据独立。

Runnable接口比Thread类所具有的优势：

• 通过创建任务，再给线程分配的方式来实现的多线程，更适合多个线程执行相同任务的情况
• 可以避免单继承带来的局限性
• 任务与线程本身是分离的，提高了程序的健壮性
• 在线程池中，接收Runnable类型的线程，不接收Thread类型的线程.

3. 实现Callable接口 (利用FutureTask执行任务 有返回值)

测试实例：
创建MyCallable类实现Callable<T>接口，重写call()方法

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程输出 === " + i);
        }
        return 100;
    }
}

MyCallableTest类测试Callable实现多线程

public class MyCallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1.创建Callable对象
        Callable<Integer> callable = new MyCallable();
        // 2.创建FutureTask对象 并传入第一步编写的Callable类对象
        FutureTask<Integer> task = new FutureTask<>(callable);
        // 3.通过Thread 启动线程
        new Thread((Runnable) task).start();
        //task.get()获取返回值
        Integer j = task.get();
        System.out.println("返回值为 " + j);
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("主线程输出 === " + i);
        }
    }
}

测试结果:

子线程输出 === 0
子线程输出 === 1
子线程输出 === 2
子线程输出 === 3
子线程输出 === 4
子线程输出 === 5
子线程输出 === 6
子线程输出 === 7
子线程输出 === 8
子线程输出 === 9
返回值为 100
主线程输出 === 0
主线程输出 === 1
主线程输出 === 2
主线程输出 === 3
主线程输出 === 4
主线程输出 === 5
主线程输出 === 6
主线程输出 === 7
主线程输出 === 8
主线程输出 === 9

Process finished with exit code 0

这里的测试结果，是子线程先输出完，输出返回值再执行主线程的原因是，task.get()方法获取返回值的时候会导致主线程在这时候停在这里等子线程执行完毕，等获取完返回值后，不再等待子线程了，就开始执行主线程。

Callable接口和Runnable接口的区别

• 两个接口需要实现的方法名不一样，Runnable需要实现的方法为run()，Callable需要实现的方法为call()。
• 实现的方法返回值不一样，Runnable任务执行后无返回值，Callable任务执行后可以得到异步计算的结果。
• 抛出异常不一样，Runnable不可以抛出异常，Callable可以抛出异常。

Callable接口相对来说用的少一些，不过在面试中偶尔会问到多线程有返回值的实现方式。

线程的状态

线程可以处于以下状态之一：

• NEW
  尚未启动的线程处于此状态。
• RUNNABLE
  在Java虚拟机中执行的线程处于此状态。
• BLOCKED
  被阻塞等待监视器锁定的线程处于此状态。
• WAITING
  无限期等待另一个线程执行特定操作的线程处于此状态。
• TIMED_WAITING
  正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
• TERMINATED
  已退出的线程处于此状态。

以上是JDK11API帮助文档中给出的线程的六种状态。
线程状态转换图：

线程的调度

Java线程有优先级，优先级高的线程会更优先的抢占CPU时间片。
Java线程的优先级用整数表示，取值范围是1~10，
Thread类有以下三个静态常量：

• static int MAX_PRIORITY线程可以具有的最高优先级，取值为10。
• static int MIN_PRIORITY线程可以具有的最低优先级，取值为1。
• static int NORM_PRIORITY分配给线程的默认优先级，取值为5。

Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。

线程安全问题

通过一个实例演示线程不安全的问题，是一个买票的情况

public class Demo {

    public static void main(String[] args) {
        Runnable runnable = new Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 10;

        @Override
        public void run() {
            while (count > 0) {
                //买票
                System.out.println("正在买票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("买票成功 已出票 余票数为: " + count);
            }
        }
    }
}

测试结果：

正在买票
正在买票
正在买票
买票成功 已出票 余票数为: 9
正在买票
买票成功 已出票 余票数为: 8
正在买票
买票成功 已出票 余票数为: 7
正在买票
买票成功 已出票 余票数为: 5
正在买票
买票成功 已出票 余票数为: 4
正在买票
买票成功 已出票 余票数为: 6
正在买票
买票成功 已出票 余票数为: 2
正在买票
买票成功 已出票 余票数为: 1
正在买票
买票成功 已出票 余票数为: 3
正在买票
买票成功 已出票 余票数为: 0
买票成功 已出票 余票数为: -2
买票成功 已出票 余票数为: -1

Process finished with exit code 0

可以看到这时候线程是出现了不安全问题的，按道理来说经过while (count>0)，是不可能余票数小于0还出现-1、-2的情况的。这就是多线程的不安全问题。

原因通过图解

这是一开始的初始状态，有三个线程，count是初始的10.

到了临界状态count=1，当A拿到cpu时间片，进入了循环，还没到count--，因为加了休眠环节，更容易出现这样的线程不安全问题，因为A进入sleep()休眠所以B,C也会相继抢到时间片，当三个线程都进入了，当A线程休眠结束count--，count=0，紧接着到B，C线程执行就会出现-1,-2的线程不安全情况了。

这里造成线程不安全的原因就是多个线程去争抢一个资源(操作一个数据)导致的，导致了在判断和使用数据的时候数据不一样，因为中间还多了执行的代码，被其他线程插入了，把数据改变了，因此导致了数据不符合预期。

解决1. 同步代码块(隐式锁)

同步(synchronized)代码块：只需要将操作共享数据的代码放在synchronized
代码测试：

public class Demo {

    public static void main(String[] args) {
        Runnable runnable = new Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 10;
        private Object o = new Object();

        @Override
        public void run() {
            while (true) {
                synchronized (o) {
                    if (count > 0) {
                        //买票
                        System.out.println("正在买票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "买票成功 已出票 余票数为: " + count);
                    }else {
                        break;
                    }
                }
            }
        }
    }
}

测试结果：

正在买票
Thread-0买票成功 已出票 余票数为: 9
正在买票
Thread-0买票成功 已出票 余票数为: 8
正在买票
Thread-0买票成功 已出票 余票数为: 7
正在买票
Thread-0买票成功 已出票 余票数为: 6
正在买票
Thread-0买票成功 已出票 余票数为: 5
正在买票
Thread-0买票成功 已出票 余票数为: 4
正在买票
Thread-0买票成功 已出票 余票数为: 3
正在买票
Thread-0买票成功 已出票 余票数为: 2
正在买票
Thread-0买票成功 已出票 余票数为: 1
正在买票
Thread-0买票成功 已出票 余票数为: 0

Process finished with exit code 0

可以看到票数已经没有多卖到-1,-2了，解决了线程安全的问题，就是执行的效率变低了。

解决2. 同步方法(隐式锁)

同步(synchronized)方法：将操作共享数据的代码抽取出来放到一个synchronized方法里面就可以了
代码测试：

public class Demo {

    public static void main(String[] args) {
        Runnable runnable = new Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 10;
        private Object o = new Object();

        @Override
        public void run() {
            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }

        public synchronized boolean sale(){
            if (count > 0) {
                //买票
                System.out.println("正在买票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "买票成功 已出票 余票数为: " + count);
                return true;
            }
            return false;
        }
    }
}

结果测试：

正在买票
Thread-0买票成功 已出票 余票数为: 9
正在买票
Thread-2买票成功 已出票 余票数为: 8
正在买票
Thread-2买票成功 已出票 余票数为: 7
正在买票
Thread-2买票成功 已出票 余票数为: 6
正在买票
Thread-2买票成功 已出票 余票数为: 5
正在买票
Thread-2买票成功 已出票 余票数为: 4
正在买票
Thread-2买票成功 已出票 余票数为: 3
正在买票
Thread-2买票成功 已出票 余票数为: 2
正在买票
Thread-2买票成功 已出票 余票数为: 1
正在买票
Thread-2买票成功 已出票 余票数为: 0

Process finished with exit code 0

可以看到结果与同步代码块是一样的，都不会有线程安全问题了。

可以看到两次测试结果不一样，前面都是Thread-0线程出票，是因为最开始是Thread-0先运行的，抢占到了synchronized锁，循环了一遍标记了锁又继续抢占，因为相对来说它是最靠近的，因此一抢占到后面都会更容易抢占到。

• 需要注意的是用隐式锁synchronized的两种方式都需要在同一个锁上面，如果多个线程分别用的都是不同的synchronized，那就是无效的了，因为无法进行同步。

解决3. Lock锁(显式锁)

加同步锁 lock() 以及释放同步锁unlock()
测试代码

public class Demo01 {
    public static void main(String[] args) {
        Runnable runnable = new Demo.Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 10;
        //显式锁
        private Lock l = new ReentrantLock();

        @Override
        public void run() {
            while (true) {
                //锁
                l.lock();
                if (count > 0) {
                    //买票
                    System.out.println("正在买票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "买票成功 已出票 余票数为: " + count);
                }else{
                    break;
                }
                //解锁
                l.unlock();
            }
        }
    }
}

测试结果:

正在买票
Thread-0买票成功 已出票 余票数为: 9
正在买票
Thread-0买票成功 已出票 余票数为: 8
正在买票
Thread-0买票成功 已出票 余票数为: 7
正在买票
Thread-0买票成功 已出票 余票数为: 6
正在买票
Thread-0买票成功 已出票 余票数为: 5
正在买票
Thread-0买票成功 已出票 余票数为: 4
正在买票
Thread-0买票成功 已出票 余票数为: 3
正在买票
Thread-0买票成功 已出票 余票数为: 2
正在买票
Thread-0买票成功 已出票 余票数为: 1
正在买票
Thread-0买票成功 已出票 余票数为: 0

Process finished with exit code 0

测试结果一样解决了线程安全问题，不会再出现卖票数据错乱。

什么是死锁、活锁？

• 死锁：是指两个或两个以上的进程（或线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，都无法执行就形成死锁。
• 活锁：任务或者线程没有被阻塞，由于某些条件没有满足，导致一直重复尝试，失败，导致处于阻塞或者排队状态就形成活锁。

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

• 降低资源消耗。
• 提高响应速度。
• 提高线程的可管理性。

Java中的四种线程池 ExecutorService

1. 缓存线程池

长度无限制，首先判断线程池是否存在空闲线程，存在则使用，不存在,则创建线程并放入线程池, 然后使用。

public class Demo01 {
    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();
        //向线程池中 加入 新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:" + Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:" + Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:" + Thread.currentThread().getName());
            }
        });
    }
}

2. 定长线程池

长度是指定的数值，先判断线程池是否存在空闲线程，存在则使用，不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用；不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程。

public class Demo02 {
    public static void main(String[] args) {
       
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

3. 单线程线程池

效果与定长线程池相同

public class Demo03 {
    public static void main(String[] args) {
   
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

4. 周期性任务定长线程池

public class Demo04 {
    public static void main(String[] args) {
        /**
         * 周期任务 定长线程池.
         * 执行流程:
         * 1. 判断线程池是否存在空闲线程
         * 2. 存在则使用
         * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
         * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
         *
         * 周期性任务执行时:
         * 定时执行, 当某个时机触发时, 自动执行某任务 .
         */
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 定时执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字
         * 参数3. 时长数字的单位
         */
        /*service.schedule(new Runnable() {
        @Override
        public void run() {
        System.out.println("周期性任务定长线程");
        }
        },5,TimeUnit.SECONDS);
        */
        /**
         * 周期执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字(延迟执行的时长)
         * 参数3. 周期时长(每次执行的间隔时间)
         * 参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("周期执行线程");
            }
        },5,2, TimeUnit.SECONDS);
    }
}

java多线程并发涉及到的知识点太多了,后续学习再补充。