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

apesource-陈安

于 2024-02-23 17:52:56 发布

阅读量1k

点赞数 27

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_78070106/article/details/136261432

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文详细解释了线程同步锁(synchronized)在Java中的必要性，通过示例展示了如何使用synchronized解决多线程共享资源的安全问题，以及synchronized的不同用法（代码块、实例方法和静态方法）。同时介绍了锁的升级过程，包括偏向锁、轻量级锁和重量级锁。最后探讨了线程同步时的通信问题和wait/notify方法的使用。

摘要由CSDN通过智能技术生成

线程的同步锁（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;

	}

	@Override
	public 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;

	}

	@Override
	public 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();
	}
}