线程的同步（synchronized的原理和用法，解决线程同步时的通信问题）-编程知识

线程的同步锁（synchronized）

为什么会出现线程的同步锁？

因为JVM虚拟机是抢占调度模型，当多个线程在同时访问一个资源时会发生两个线程争抢一个资源，在一个线程没有执行结束时，另一个线程抢到资源，造成线程不安全的问题

这里使用一道简单的练习题说明：

package Threadday2;import java.util.concurrent.atomic.AtomicInteger;public class Test01 {public static void main(String[] args) throws InterruptedException {// 创建线程AddThread addThread = new AddThread(); //自增线程DecThread decThread = new DecThread(); //自减线程// 启动线程addThread.start();decThread.start();// 线程插队addThread.join();decThread.join();System.out.println(Counter.count);}
}class Counter {//方式一：使用锁public static int count = 0;
}class AddThread extends Thread {//方式一：public void run() {for (int i = 0; i < 10000; i++) {Counter.count += 1;}}
}class DecThread extends Thread {//方式一：public void run() {for (int i = 0; i < 10000; i++) {Counter.count -= 1;}}
}

在这里插入图片描述

创建两个线程，一个线程计算将变量count从1加到10000，一个线程将count–，再这种状态下两个线程执行结果的count变量不为0，所有会有线程不安全的状况，要想解决这个问题就要使用synchronized（线程同步锁）

下面是使用线程同步锁解决问题的逻辑及代码

首先，在Counter类中创建一个静态的Object类的常量当做锁对象
其次，对需要加锁的代码进行加锁

package Threadday2;import java.util.concurrent.atomic.AtomicInteger;public class Test01 {public static void main(String[] args) throws InterruptedException {// 创建线程AddThread addThread = new AddThread(); //自增线程DecThread decThread = new DecThread(); //自减线程// 启动线程addThread.start();decThread.start();// 线程插队addThread.join();decThread.join();System.out.println(Counter.count);}
}class Counter {//方式一：使用锁public static int count = 0;public static final Object LOCK = new Object();}class AddThread extends Thread {//方式一：public void run() {for (int i = 0; i < 10000; i++) {// 加锁synchronized (Counter.LOCK) {Counter.count += 1;}}}
}class DecThread extends Thread {//方式一：public void run() {for (int i = 0; i < 10000; i++) {// 加锁synchronized (Counter.LOCK) {Counter.count -= 1;}}}
}

在这里插入图片描述

这个就是一种synchronized线程同步锁的应用（是使用代码块的方式：通过一个公共对象，作为“锁”）

synchronized用法

1.通过代码块的方式创建：通过一个公共对象，作为“锁”（上面的案例就是运用了这种方法）

2.通过实例方法：方法声明中直接使用synchronized关键字（作用等同于使用this作为锁）

package Threadday2;public class Test04 {//方法一:使用当前this对象，作为锁对象public void dosth1() {synchronized (this) {System.out.println("............");}}// 实例方法//方法二：方法声明中直接使用synchronized关键字（作用等同于使用this作为锁）public synchronized void dosth2() {}
}

3.静态方法：方法声明中直接使用synchronized关键字（作用等同于使用当前类的class对象作为锁）

package Threadday2;public class Test05 {//方法一:使用当前类的class对象，作为锁对象public static void dosth1() {synchronized (Test05.class) {System.out.println("............");}}//静态方法//方法二：方法声明中直接使用synchronized关键字（作用等同于使用当前类的class对象作为锁）public synchronized static void dosth2() {}
}

synchronized原理

原理：通过monitorenter/monitorexit指令实现监视器机制。

Moniter监视器

每一个对象都会和一个监视器monitor关联。监视器被占用时会被锁住，其他线程无法来获取monitor。当JVM执行某个线程的某个方法内部的monitorenter时，它会尝试去获取当前对象对应的monitor的所有权。其过程如下：

若monitor的进入数为0，线程进入monitor，并将monitor的进入数量为1,当前线程成为monitor的owner（所有者）
若线程已拥有monitor的所有权，允许它重入monitor，则进入monitor的数量加1
若其他线程已经占有monitor的所有权，那么当前尝试monitor所有权的线程会被阻塞，直到monitor的进入数变为0，才能重新尝试获取monitor的所有权

对monitorexit的理解：

能执行monitorexit的线程一定是拥有当前对象的monitor的所有权的线程
执行monitorexit时，会将monitor的进入数减一，当monitor的进入数减为0时，当前线程退出monitor，不再拥有monitor的所有权，此时其他线程就可以尝试获取monitor的所有权

获取步骤

执行monitorenter指令，判断当前monitor监视器的线程进入数量：如果为0，则该线程直接进入监视器owner，代表该线程拥有监视器，同时进入数设置为1；
如果线程已经拥有该monitor监视器，重新进入，则进入数+1；如果其它线程尝试获取监视器，则进入阻塞区，线程进入阻塞状态，直到监视器的进入数为0；
执行monitorexit指令，进入数-1

锁升级（锁膨胀）

偏向(斜)锁：只有一个线程执行的场景，使用偏向锁；
轻量级锁：发现多个线程执行的场景，偏向锁升级为轻量级锁；轻量级锁不能处理并发；
重量级锁：发现多个线程并发执行的场景，轻量级锁升级为重量级锁；重量级锁通过操作系统的“互斥锁”实现。互斥锁实现线程之间的切换，需要从“用户态”切换到“内核态”，付出高昂的代价，会导致性能下降。

线程同步时的通信问题

这里我使用一个案例来说明线程同步时的通信问题，当我创建两个线程交替打印，一个线程是数字线程，一个线程是字母线程，交替打印出12A 34B 56C 78D 910E …等时；

我的解题思路是先判断当数字等于奇数是打印出空格，当数字等于偶数是将数字线程处于等待状态，在字母线程打印出字母后，将字母线程处于等待状态，但是这么写就会导致在打印出 12A 后线程不执行了，线程不执行的原因是，因为两个线程都处于等待状态，所有要在他们进入等待状态前唤醒所有处于等待状态的线程

下面是代码分享

Number类（代表的是数字线程）

package Threadday2;public class Number implements Runnable {private final Object LOCK;public Number(Object lock) {LOCK = lock;}@Overridepublic void run() {synchronized (LOCK) {for (int i = 1; i <= 52; i++) {if (i % 2 == 1) {System.out.print(" ");}System.out.print(i);if (i % 2 == 0) {// 唤醒所有处于等待状态的线程（字母线程）LOCK.notifyAll();try {// 数字线程进入等待状态LOCK.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}

Charater类（代表字母线程）

package Threadday2;public class Charater implements Runnable {private final Object LOCK;public Charater(Object lock) {LOCK = lock;}@Overridepublic void run() {synchronized (LOCK) {for (char c = 'A'; c <= 'Z'; c++) {System.out.print(c);//唤醒所有处于等待状态的线程（数字线程）LOCK.notifyAll();if (c < 'Z') {try {//字母线程进入等待状态LOCK.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}

执行线程的代码

package Threadday2;public class Test03 {public static void main(String[] args) {final Object lock = new Object();Thread thread1 = new Thread(new Number(lock),"数字子线程");Thread thread2 = new Thread(new Charater(lock),"字母子线程");thread1.start();thread2.start();}
}