Java多线程详解，一篇文章全部搞定(全文干货，万字“血书“，值得收藏)

文章目录

一.线程的创建和使用

1.Thread类

Java虚拟机允许程序运行多个线程，它通过java.lang.Thread 类来体现。
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。
Thread类的构造器：
- Thread():创建新的Thread对象
- Thread(String threadName):创建线程并指定线程实例名
- Thread(Runnable target):指定创建线程的目标对象，它实现了Runnable接口中的run方法
- Thread(Runnable target, String name):创建新的Thread对象

2.创建多线程的四种方法

继承Thread类的方式
实现Runnable接口的方式

2.1 继承Thread类的方式

步骤为以下4步骤：

创建一个继承于Thread类的子类
该子类重写Thread父类的run() 方法，将线程执行的操作声明在run()中
创建该子类的对象
通过该子类对象调用start()

代码示例：

/**
 * @Author: YuShiwen
 * @Date: 2020/11/23 1:53 PM
 * @Version: 1.0
 */

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
    
    

    //2. 该子类重写Thread父类的run() 方法，将线程执行的操作声明在run()中
    // 这里我以输出100以内的质数为例
    @Override
    public void run() {
    
    
        label:for (int i = 2; i < 100; i++) {
    
    
            for(int j = 2; j < Math.sqrt(i);j++){
    
    
                if(i % j == 0){
    
    
                    continue label;
                }
            }
            System.out.println(Thread.currentThread().getName()+":质数"+i);
        }
    }
}

public class ThreadTestByInherit {
    
    

    public static void main(String[] args) {
    
    
        //3. 创建该子类的对象
        MyThread myThread = new MyThread();

        //4. 通过该子类对象调用start()
        myThread.start();

        //如果直接调用run(),是main线程，没有达到多线程的目的
        //myThread.run();

        //主线程输出
        System.out.println(Thread.currentThread().getName()+"：我是主线程");


    }
}

输出结果：

main：我是主线程
Thread-0:质数2
Thread-0:质数3
Thread-0:质数4
Thread-0:质数5
Thread-0:质数7
Thread-0:质数9
Thread-0:质数11
Thread-0:质数13
Thread-0:质数17
Thread-0:质数19
Thread-0:质数23
Thread-0:质数25
Thread-0:质数29
Thread-0:质数31
Thread-0:质数37
Thread-0:质数41
Thread-0:质数43
Thread-0:质数47
Thread-0:质数49
Thread-0:质数53
Thread-0:质数59
Thread-0:质数61
Thread-0:质数67
Thread-0:质数71
Thread-0:质数73
Thread-0:质数79
Thread-0:质数83
Thread-0:质数89
Thread-0:质数97

Process finished with exit code 0

注意点：

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
想要启动多线程，必须调用start方法。
一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

2.2 实现Runnable接口

步骤为以下5个步骤：

创建一个实现了Runnable接口的类
实现类去实现Runnable中的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()

代码示例：

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
    
    
    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
    
    
        label:for (int i = 2; i < 100; i++) {
    
    
            for(int j = 2; j < Math.sqrt(i);j++){
    
    
                if(i % j == 0){
    
    
                    continue label;
                }
            }
            System.out.println(Thread.currentThread().getName()+":质数"+i);
        }
    }
}

public class ThreadTestByRunnable {
    
    
    public static void main(String[] args) {
    
    
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(mThread);
        //5. 通过Thread类的对象调用start()
        thread.start();
    }
}

输出结果：

Thread-0:质数2
Thread-0:质数3
Thread-0:质数4
Thread-0:质数5
Thread-0:质数7
Thread-0:质数9
Thread-0:质数11
Thread-0:质数13
Thread-0:质数17
Thread-0:质数19
Thread-0:质数23
Thread-0:质数25
Thread-0:质数29
Thread-0:质数31
Thread-0:质数37
Thread-0:质数41
Thread-0:质数43
Thread-0:质数47
Thread-0:质数49
Thread-0:质数53
Thread-0:质数59
Thread-0:质数61
Thread-0:质数67
Thread-0:质数71
Thread-0:质数73
Thread-0:质数79
Thread-0:质数83
Thread-0:质数89
Thread-0:质数97

Process finished with exit code 0

上述两种方式的比较

继承Thread：线程代码存放在Thread子类run方法中。
实现Runnable：线程代码存放在接口实现类的run方法中。
两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
在开发中，优先选择实现Runnable接口的方式
- 因为实现的方式没有类的单继承性的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

2.3 实现Callable接口(JDK 5.0新增)

与使用Runnable相比， Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
- Future接口
  - 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
  - FutrueTask是Futrue接口的唯一的实现类
  - FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    
    
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
    
    
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    
    
    public static void main(String[] args) {
    
    
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
    
    
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        } catch (ExecutionException e) {
    
    
            e.printStackTrace();
        }
    }

}

输出结果：

2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50
52
54
56
58
60
62
64
66
68
70
72
74
76
78
80
82
84
86
88
90
92
94
96
98
100
总和为：2550

Process finished with exit code 0

2.4 使用线程池

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止

代码示例：

class NumberThread implements Runnable{
    
    

    @Override
    public void run() {
    
    
        for(int i = 0;i <= 100;i++){
    
    
            if(i % 2 == 0){
    
    
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{
    
    

    @Override
    public void run() {
    
    
        for(int i = 0;i <= 100;i++){
    
    
            if(i % 2 != 0){
    
    
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPoolTest {
    
    

    public static void main(String[] args) {
    
    
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

输出结果：

pool-1-thread-1: 0
pool-1-thread-1: 2
pool-1-thread-1: 4
pool-1-thread-1: 6
pool-1-thread-1: 8
pool-1-thread-1: 10
pool-1-thread-1: 12
pool-1-thread-1: 14
pool-1-thread-1: 16
pool-1-thread-1: 18
pool-1-thread-1: 20
pool-1-thread-1: 22
pool-1-thread-1: 24
pool-1-thread-1: 26
pool-1-thread-1: 28
pool-1-thread-1: 30
pool-1-thread-1: 32
pool-1-thread-1: 34
pool-1-thread-1: 36
pool-1-thread-1: 38
pool-1-thread-1: 40
pool-1-thread-1: 42
pool-1-thread-1: 44
pool-1-thread-1: 46
pool-1-thread-1: 48
pool-1-thread-1: 50
pool-1-thread-1: 52
pool-1-thread-1: 54
pool-1-thread-1: 56
pool-1-thread-1: 58
pool-1-thread-1: 60
pool-1-thread-1: 62
pool-1-thread-1: 64
pool-1-thread-1: 66
pool-1-thread-1: 68
pool-1-thread-1: 70
pool-1-thread-1: 72
pool-1-thread-1: 74
pool-1-thread-2: 1
pool-1-thread-2: 3
pool-1-thread-2: 5
pool-1-thread-2: 7
pool-1-thread-2: 9
pool-1-thread-2: 11
pool-1-thread-2: 13
pool-1-thread-2: 15
pool-1-thread-2: 17
pool-1-thread-2: 19
pool-1-thread-2: 21
pool-1-thread-2: 23
pool-1-thread-2: 25
pool-1-thread-2: 27
pool-1-thread-2: 29
pool-1-thread-2: 31
pool-1-thread-2: 33
pool-1-thread-2: 35
pool-1-thread-2: 37
pool-1-thread-2: 39
pool-1-thread-2: 41
pool-1-thread-2: 43
pool-1-thread-2: 45
pool-1-thread-2: 47
pool-1-thread-2: 49
pool-1-thread-2: 51
pool-1-thread-2: 53
pool-1-thread-2: 55
pool-1-thread-2: 57
pool-1-thread-2: 59
pool-1-thread-2: 61
pool-1-thread-2: 63
pool-1-thread-2: 65
pool-1-thread-2: 67
pool-1-thread-2: 69
pool-1-thread-2: 71
pool-1-thread-2: 73
pool-1-thread-2: 75
pool-1-thread-2: 77
pool-1-thread-2: 79
pool-1-thread-2: 81
pool-1-thread-2: 83
pool-1-thread-2: 85
pool-1-thread-2: 87
pool-1-thread-2: 89
pool-1-thread-2: 91
pool-1-thread-2: 93
pool-1-thread-2: 95
pool-1-thread-2: 97
pool-1-thread-2: 99
pool-1-thread-1: 76
pool-1-thread-1: 78
pool-1-thread-1: 80
pool-1-thread-1: 82
pool-1-thread-1: 84
pool-1-thread-1: 86
pool-1-thread-1: 88
pool-1-thread-1: 90
pool-1-thread-1: 92
pool-1-thread-1: 94
pool-1-thread-1: 96
pool-1-thread-1: 98
pool-1-thread-1: 100

Process finished with exit code 0

二.Thread类的相关方法

start():启动当前线程；调用当前线程的run()方法
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread():静态方法，返回执行当前代码的线程
getName():获取当前线程的名字
setName():设置当前线程的名字
yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
stop():已过时。当执行此方法时，强制结束当前线程，不推荐使用。
sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive():判断当前线程是否存活

代码示例：

class MyThreadClass extends Thread{
    
    
    @Override
    public void run() {
    
    
        label:for (int i = 2; i < 100; i++) {
    
    
            for(int j = 2; j < Math.sqrt(i);j++){
    
    
                if(i % j == 0){
    
    
                    continue label;
                }
            }
            System.out.println(Thread.currentThread().getName()+":质数"+i);
        }
    }

    public MyThreadClass() {
    
    
        super();
    }

    public MyThreadClass(String name) {
    
    
        super(name);
    }
}

public class ThreadMethodTest{
    
    
    public static void main(String[] args) {
    
    
        MyThreadClass thread0 = new MyThreadClass();
        MyThreadClass thread1 = new MyThreadClass("线程二");

        //getName():获取当前线程的名字
        System.out.println(thread0.getName());
        System.out.println(thread1.getName());

        //setName():设置当前线程的名字
        thread0.setName("线程一");
        System.out.println();
        System.out.println(thread0.getName());
        System.out.println(thread1.getName());

        //currentThread():静态方法，返回执行当前代码的线程
        System.out.println(Thread.currentThread().getName());


        //start():启动当前线程；调用当前线程的run()方法
        thread0.start();
        thread1.start();


        //join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
        try {
    
    
            thread0.join();
            thread1.join();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }

        //直接调用run方法，此时是主线程直接调用的
        thread0.run();

        //yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。
        Thread.yield();

        //sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
        //这里让主线程阻塞3秒
        try {
    
    
            Thread.sleep(3000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }

        //isAlive():判断当前线程是否存活
        System.out.println(thread0.isAlive());
        System.out.println(thread1.isAlive());


    }
}

输出结果：

Thread-0
线程二

线程一
线程二
main
线程二:质数2
线程二:质数3
线程二:质数4
线程二:质数5
线程二:质数7
线程一:质数2
线程一:质数3
线程一:质数4
线程一:质数5
线程一:质数7
线程一:质数9
线程一:质数11
线程一:质数13
线程二:质数9
线程二:质数11
线程二:质数13
线程二:质数17
线程二:质数19
线程二:质数23
线程二:质数25
线程二:质数29
线程二:质数31
线程二:质数37
线程二:质数41
线程二:质数43
线程一:质数17
线程二:质数47
线程二:质数49
线程二:质数53
线程二:质数59
线程二:质数61
线程二:质数67
线程二:质数71
线程二:质数73
线程二:质数79
线程二:质数83
线程二:质数89
线程二:质数97
线程一:质数19
线程一:质数23
线程一:质数25
线程一:质数29
线程一:质数31
线程一:质数37
线程一:质数41
线程一:质数43
线程一:质数47
线程一:质数49
线程一:质数53
线程一:质数59
线程一:质数61
线程一:质数67
线程一:质数71
线程一:质数73
线程一:质数79
线程一:质数83
线程一:质数89
线程一:质数97
main:质数2
main:质数3
main:质数4
main:质数5
main:质数7
main:质数9
main:质数11
main:质数13
main:质数17
main:质数19
main:质数23
main:质数25
main:质数29
main:质数31
main:质数37
main:质数41
main:质数43
main:质数47
main:质数49
main:质数53
main:质数59
main:质数61
main:质数67
main:质数71
main:质数73
main:质数79
main:质数83
main:质数89
main:质数97
false
false

Process finished with exit code 0

三.线程的调度、优先级、分类和生命周期

1.线程的调度

调度策略：时间片轮转策略和抢占式策略
Java的调度方法：
- 同优先级线程组成先进先出队列(先到先服务)，使用时间片轮转策略
- 对高优先级，使用优先调度的抢占式策略

2.线程的优先级

常量表示的优先级：MAX_PRIORITY:10、MIN _PRIORITY:1、NORM_PRIORITY:5
setPriority(int newPriority) :改变线程的优先级
getPriority() :返回线程优先值
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

3.线程的分类

Java中的线程分为两类:一种是守护线程，一种是用户线程。
守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。

截图示例：在上述二.Thread类的相关方法的代码示例中加上如下代码段：

在这里插入图片描述
输出结果：把用户线程全部改为了守护线程，JVM中都是守护线程，当前JVM将退出。

在这里插入图片描述

4.线程的生命周期

Java线程它的一个完整的生命周期中通常要经历如下的五种状态:

新建: 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪:处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

在这里插入图片描述

四.线程的同步

1.同步代码块

synchronized(同步监视器){
//需要被同步的代码
}

需要被同步的代码不能包含代码多了，也不能包含代码少了。
操作共享数据的代码，即为需要被同步的代码。
共享数据：多个线程共同操作的变量。
同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
多个线程必须要共用同一把锁。
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

1.1同步代码块解决继承Thread类方式的线程安全问题

代码示例：

/**
 * @Author: YuShiwen
 * @Date: 2020/11/24 2:42 PM
 * @Version: 1.0
 */

class Seat extends Thread{
    
    
    private static int position = 100;

    private static Object obj = new Object();

    @Override
    public void run() {
    
    
        while(true){
    
    
            synchronized (obj) {
    
    //或者synchronized (Seat.class)，只需要保证同步监视器相同即可
                if (position > 0) {
    
    
                    try {
    
    
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    System.out.println("从"+this.getName() + "得到座位，座位号为：" + position);
                    --position;
                } else {
    
    
                    break;
                }
            }
        }
    }
}

public class SeatTest {
    
    
    public static void main(String[] args) {
    
    
        Seat seat0 = new Seat();
        Seat seat1 = new Seat();
        Seat seat2 = new Seat();

        seat0.setName("渠道一");
        seat1.setName("渠道二");
        seat2.setName("渠道三");

        seat0.start();
        seat1.start();
        seat2.start();
    }
}

输出结果：

从渠道一得到座位，座位号为：100
从渠道一得到座位，座位号为：99
从渠道三得到座位，座位号为：98
从渠道三得到座位，座位号为：97
从渠道三得到座位，座位号为：96
从渠道三得到座位，座位号为：95
从渠道三得到座位，座位号为：94
从渠道三得到座位，座位号为：93
从渠道三得到座位，座位号为：92
从渠道三得到座位，座位号为：91
从渠道三得到座位，座位号为：90
从渠道三得到座位，座位号为：89
从渠道三得到座位，座位号为：88
从渠道三得到座位，座位号为：87
从渠道三得到座位，座位号为：86
从渠道三得到座位，座位号为：85
从渠道三得到座位，座位号为：84
从渠道三得到座位，座位号为：83
从渠道二得到座位，座位号为：82
从渠道二得到座位，座位号为：81
从渠道二得到座位，座位号为：80
从渠道二得到座位，座位号为：79
从渠道二得到座位，座位号为：78
从渠道二得到座位，座位号为：77
从渠道二得到座位，座位号为：76
从渠道二得到座位，座位号为：75
从渠道二得到座位，座位号为：74
从渠道二得到座位，座位号为：73
从渠道二得到座位，座位号为：72
从渠道二得到座位，座位号为：71
从渠道二得到座位，座位号为：70
从渠道二得到座位，座位号为：69
从渠道二得到座位，座位号为：68
从渠道二得到座位，座位号为：67
从渠道二得到座位，座位号为：66
从渠道二得到座位，座位号为：65
从渠道二得到座位，座位号为：64
从渠道二得到座位，座位号为：63
从渠道二得到座位，座位号为：62
从渠道三得到座位，座位号为：61
从渠道三得到座位，座位号为：60
从渠道三得到座位，座位号为：59
从渠道三得到座位，座位号为：58
从渠道三得到座位，座位号为：57
从渠道三得到座位，座位号为：56
从渠道三得到座位，座位号为：55
从渠道三得到座位，座位号为：54
从渠道三得到座位，座位号为：53
从渠道三得到座位，座位号为：52
从渠道三得到座位，座位号为：51
从渠道三得到座位，座位号为：50
从渠道三得到座位，座位号为：49
从渠道三得到座位，座位号为：48
从渠道三得到座位，座位号为：47
从渠道三得到座位，座位号为：46
从渠道三得到座位，座位号为：45
从渠道三得到座位，座位号为：44
从渠道三得到座位，座位号为：43
从渠道三得到座位，座位号为：42
从渠道三得到座位，座位号为：41
从渠道三得到座位，座位号为：40
从渠道三得到座位，座位号为：39
从渠道三得到座位，座位号为：38
从渠道三得到座位，座位号为：37
从渠道三得到座位，座位号为：36
从渠道三得到座位，座位号为：35
从渠道三得到座位，座位号为：34
从渠道三得到座位，座位号为：33
从渠道三得到座位，座位号为：32
从渠道三得到座位，座位号为：31
从渠道三得到座位，座位号为：30
从渠道一得到座位，座位号为：29
从渠道一得到座位，座位号为：28
从渠道一得到座位，座位号为：27
从渠道一得到座位，座位号为：26
从渠道一得到座位，座位号为：25
从渠道三得到座位，座位号为：24
从渠道三得到座位，座位号为：23
从渠道三得到座位，座位号为：22
从渠道三得到座位，座位号为：21
从渠道三得到座位，座位号为：20
从渠道三得到座位，座位号为：19
从渠道三得到座位，座位号为：18
从渠道三得到座位，座位号为：17
从渠道三得到座位，座位号为：16
从渠道三得到座位，座位号为：15
从渠道三得到座位，座位号为：14
从渠道三得到座位，座位号为：13
从渠道三得到座位，座位号为：12
从渠道三得到座位，座位号为：11
从渠道三得到座位，座位号为：10
从渠道三得到座位，座位号为：9
从渠道三得到座位，座位号为：8
从渠道二得到座位，座位号为：7
从渠道二得到座位，座位号为：6
从渠道二得到座位，座位号为：5
从渠道二得到座位，座位号为：4
从渠道二得到座位，座位号为：3
从渠道三得到座位，座位号为：2
从渠道三得到座位，座位号为：1

Process finished with exit code 0

1.2同步代码块解决实现Runnable接口方式的线程安全问题

class Seat1 implements Runnable{
    
    
    private int position = 100;

    @Override
    public void run() {
    
    
        while(true){
    
    
            synchronized (this) {
    
    
                if (position > 0) {
    
    
                    try {
    
    
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position);
                    --position;
                } else {
    
    
                    break;
                }
            }
        }
    }
}

public class SeatTest1 {
    
    
    public static void main(String[] args) {
    
    
        Seat1 seat1 = new Seat1();

        Thread thread0 = new Thread(seat1);
        Thread thread1 = new Thread(seat1);
        Thread thread2 = new Thread(seat1);

        thread0.setName("渠道一");
        thread1.setName("渠道二");
        thread2.setName("渠道三");

        thread0.start();
        thread1.start();
        thread2.start();
    }
}

输出结果：与上述结果差不多，这里为节省篇幅省略。

2.同步方法

synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如:
public synchronized void show (String name){ …
}

2.1使用同步方法处理继承Thread类方式中的线程安全问题

class Seat2 extends Thread{
    
    
    private static int position = 100;

    @Override
    public void run() {
    
    
        while (true){
    
    
            getPosition();
        }
    }

    //默认同步监视器：Seat2.class
    private static synchronized void getPosition(){
    
    
        if(position > 0){
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }

            System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position);
            --position;
        }
    }
}
public class SeatTest2 {
    
    
    public static void main(String[] args) {
    
    
        Seat2 seat0 = new Seat2();
        Seat2 seat1 = new Seat2();
        Seat2 seat2 = new Seat2();

        seat0.setName("渠道一");
        seat1.setName("渠道二");
        seat2.setName("渠道三");

        seat0.start();
        seat1.start();
        seat2.start();
    }
}

输出结果：与上述结果差不多，这里为节省篇幅省略。

2.2使用同步方法解决实现Runnable接口的线程安全问题

在这里插入代码片class Seat3 implements Runnable{
    
    
    private int position = 100;

    @Override
    public void run() {
    
    
        while (true){
    
    
            getPosition();
        }
    }

    //默认同步监视器：this
    private synchronized void getPosition(){
    
    
        if(position > 0){
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }

            System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position);
            --position;
        }
    }
}

public class SeatTest3 {
    
    
    public static void main(String[] args) {
    
    
        Seat3 seat3 = new Seat3();

        Thread thread0 = new Thread(seat3);
        Thread thread1 = new Thread(seat3);
        Thread thread2 = new Thread(seat3);

        thread0.setName("渠道一");
        thread1.setName("渠道二");
        thread2.setName("渠道三");

        thread0.start();
        thread1.start();
        thread2.start();
    }
}

输出结果：与上述结果差不多，这里为节省篇幅省略。

3.Lock（锁）

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

class A{
	private final ReentrantLock lock = new ReenTrantLock();
 	public void method(){
		lock.lock();
		try{
			//保证线程安全的代码;
		} finally{
			lock.unlock();
		} 
	}
}

ps:如果同步代码有异常，要将unlock()写入finally语句块

代码示例：

class Seat implements Runnable{
    
    
    private int position = 100;

    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
    
    
        while(true){
    
    
            try{
    
    
                //2.调用锁定方法lock()
                lock.lock();
                if(position >0){
    
    
                    try {
    
    
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    System.out.println("从"+Thread.currentThread().getName()+"得到座位，座位号为：" + position);
                    --position;
                }else {
    
    
                    break;
                }
            }finally {
    
    
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    
    
    public static void main(String[] args) {
    
    
        Seat seat = new Seat();

        Thread thread0 = new Thread(seat);
        Thread thread1 = new Thread(seat);
        Thread thread2 = new Thread(seat);

        thread0.setName("渠道一");
        thread1.setName("渠道二");
        thread2.setName("渠道三");

        thread0.start();
        thread1.start();
        thread2.start();
    }
}

4.synchronized 与 Lock 的对比

Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)

5.释放锁和不会释放锁的操作

释放锁的操作

当前线程的同步方法、同步代码块执行结束。
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的操作
线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁(同步监视器)。
应尽量避免使用suspend()和resume()来控制线程

五.线程的通信

wait() 与 notify() 和 notifyAll()
- wait():令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
- notifyAll ():唤醒正在排队等待资源的所有线程结束等待.
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

线程通信的应用：经典例题：生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

class Clerk{
    
    

    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
    
    

        if(productCount < 20){
    
    
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");

            notify();

        }else{
    
    
            //等待
            try {
    
    
                wait();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }

    }
    //消费产品
    public synchronized void consumeProduct() {
    
    
        if(productCount > 0){
    
    
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;

            notify();
        }else{
    
    
            //等待
            try {
    
    
                wait();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }

    }
}

class Producer extends Thread{
    
    //生产者

    private Clerk clerk;

    public Producer(Clerk clerk) {
    
    
        this.clerk = clerk;
    }

    @Override
    public void run() {
    
    
        System.out.println(getName() + ":开始生产产品.....");

        while(true){
    
    

            try {
    
    
                Thread.sleep(10);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }

            clerk.produceProduct();
        }

    }
}

class Consumer extends Thread{
    
    //消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
    
    
        this.clerk = clerk;
    }

    @Override
    public void run() {
    
    
        System.out.println(getName() + ":开始消费产品.....");

        while(true){
    
    

            try {
    
    
                Thread.sleep(20);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}

public class ProductTest {
    
    

    public static void main(String[] args) {
    
    
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();

    }
}