SE高阶(5)：多线程—②线程同步、死锁、volatile关键字-CSDN博客

本文链接：https://blog.csdn.net/fengwei4618/article/details/70768244

本文深入探讨Java中线程同步的重要性和实现方式，包括synchronized关键字、Lock接口及其实现类ReentrantLock等，同时提供了丰富的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程同步的作用

在多线程中，当两个及以上线程并发访问同个资源时，尽管有控制线程的方法，但由于线程调度具有不确定性，所以极容易导致错误，这时就需要线程同步机制来解决此问题。

实现线程同步——同步监视器

Java中，任何对象都能作为同步监视器。同步监视器是为了确保一个线程在对对象操作时，别的线程无权访问，即任何时刻只能有一个线程对同步监视器锁定。所以一般把并发访问的共享资源作为同步监视器。

在Java中，使用关键字synchronized或者Lock类来对同步监视器锁定。

synchronized的用法

同步代码块：synchronized(obj){}，传入的obj对象就是同步监视器，在执行同步代码块中的代码之前，必须先获得对同步监视器的锁定。
synchronized修饰方法：同步方法的监视器是this，所以调用该方法的对象就是同步监视器，则无需显式指定。

Lock的用法

有ReentrantLock(可重入锁)、ReentrantReadWriteLock(可重入读写锁)、以及Java8新增的StampedLock类。
Lock对象相当于同步监视器对象，并发访问时，每次只能允许一个线程对Lock对象加锁，执行完之后必须手动释放锁，释放锁方法一定要放在finally语句中。
另外ReentrantReadWriteLock(提供了三种读写操作模式，但不常用。

线程同步实例

先给上一段多线程实现的取钱代码，没有采用线程同步，看看会出现什么情况。

public class Account {
	private int balance;//余额
	public Account(int balance) {
		this.balance = balance;
		System.out.println("账户当前余额：" + balance);
	}	
	//取钱方法
	public void quqian(int money) {
		if(money <= balance) {
			System.out.println(Thread.currentThread().getName() + ",取出" + money);
			//睡眠线程2s，用于测试另一个线程
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {e.printStackTrace();}							
			//修改余额的代码
			this.balance -= money;
			System.out.println(Thread.currentThread().getName()+",余额:" + this.balance);
		}else {
			System.out.println(Thread.currentThread().getName() + "取钱失败！");
		}		
	}
}	
//执行存钱操作的Runnable线程
class QqPerson implements Runnable{
	private int money;
	private Account ac;
	public QqPerson(Account ac,int money) {
		this.ac = ac;
		this.money = money;
	}
	@Override
	public void run() {
		ac.quqian(money);		
	}
}

public class Test {
	public static void main(String[] args) {
		Account ac = new Account(1000);
		//传入Account对象、取钱金额
		QqPerson q1 = new QqPerson(ac,600);
		QqPerson q2 = new QqPerson(ac,600);
		//线程类传入Runnable对象
		Thread t1 = new Thread(q1,"取钱1号");
		Thread t2 = new Thread(q2,"取钱2号");
		//启动线程
		t1.start();
		t2.start();
	}
}

实例解析：在执行修改余额代码之前，调用sleep(2000)强制让线程睡眠2s，这样能更好地体现多个线程访问共享资源时，由于线程调度的不确定性导致的线程安全问题。事实上，如果不加sleep()，就会出现一会正确一会错误的情况。遇到这种问题，就需要使用线程同步来解决。

使用同步代码块实例

//执行存钱操作的线程
class QqPerson implements Runnable{
	private int money;
	private Account ac;
	public QqPerson(Account ac,int money) {
		this.ac = ac;
		this.money = money;
	}
	@Override
	public void run() {
		//加入同步代码块
		synchronized(ac){
			ac.quqian(money);
		}
	}
}

实例解析：其余的代码都是相同的，只是把并发访问共享资源的执行代码放入同步代码块中，在代码中，依然使用sleep()来睡眠线程，但是会发现别的线程无法执行，这是因为同步锁还未被释放，执行完后释放锁，别的线程才能获取同步锁。

使用同步方法实例

	//取钱方法
	public synchronized void quqian(int money) {
		if(money <= balance) {
			System.out.println(Thread.currentThread().getName() + ",取出" + money);
			//睡眠线程1s，用于测试另一个线程
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {e.printStackTrace();}							
			//修改余额的代码
			this.balance -= money;
			System.out.println(Thread.currentThread().getName()+",余额:" + this.balance);
		}else {
			System.out.println(Thread.currentThread().getName() + "取钱失败！");
		}		
	}

实例解析：因为并发访问共享资源的执行代码是由一个方法来完成，所以可以用synchronized修饰该方法。加锁原理和同步代码块一样，只是无需显式加入同步锁对象。
加锁流程：第一个线程执行取钱方法，先获得同步锁对象，然后执行方法内部代码，执行到sleep()会睡眠当前线程，但因为睡眠线程获得了锁对象，所以别的线程此时无权访问，睡眠时间到了之后，又开始继续执行，直到代码执行结束，然后释放锁。下一个线程开始执行，又继续前面的步骤。

使用Lock加锁实例

public class Account {
	private int balance;//余额
	ReentrantLock lock = new ReentrantLock();
	StampedLock slock = new StampedLock();
	
	public Account(int balance) {
		this.balance = balance;
		System.out.println("账户当前余额：" + balance);
	}
	//取钱方法
	public  void quqian(int money) {
		try {
			lock.lock();//加锁
			if(money <= balance) {
				System.out.println(Thread.currentThread().getName() + ",取出" + money);												
				//修改余额的代码
				this.balance -= money;
				System.out.println(Thread.currentThread().getName()+",余额:" + this.balance);
			}else {
				System.out.println(Thread.currentThread().getName() + "取钱失败！");
			}
		}finally {
			lock.unlock();//手动释放锁
		}
	}
}