Synchronized Statements作用

最新推荐文章于 2025-02-01 21:02:22 发布

王奕然

最新推荐文章于 2025-02-01 21:02:22 发布

阅读量626

点赞数

CC 4.0 BY-SA版权

分类专栏： j2se

本文链接：https://blog.youkuaiyun.com/wangyuxuan_java/article/details/8859221

j2se 专栏收录该内容

37 篇文章

订阅专栏

本文通过一个银行账户存款示例，展示了在多线程环境下使用同步锁（synchronized）来确保数据一致性和可见性的必要性。当多个线程同时访问并修改同一资源时，如果不采取适当的同步措施，可能会导致数据混乱。

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

先来看下lock的作用

intrinsic Locks and Synchronization

Synchronization is built around an internal entity known as the intrinsic lock or monitor lock. (The API specification often refers to this entity simply as a "monitor.") Intrinsic locks play a role in both aspects of synchronization: enforcing exclusive access to an object's state and establishing happens-before relationships that are essential to visibility.

Every object has an intrinsic lock associated with it. By convention, a thread that needs exclusive and consistent access to an object's fields has to acquire the object's intrinsic lock before accessing them, and then release the intrinsic lock when it's done with them. A thread is said to own the intrinsic lock between the time it has acquired the lock and released the lock. As long as a thread owns an intrinsic lock, no other thread can acquire the same lock. The other thread will block when it attempts to acquire the lock.

When a thread releases an intrinsic lock, a happens-before relationship is established between that action and any subsequent acquistion of the same lock.

我写了一个程序可以体会一下

账户account

package com.yuxuan.j2se;
/*
 * 账户
 */
public class Account {
private Integer price=300;

public void deductPrice(Integer price) {
	this.price = this.price-price;
}

public void addPrice(Integer price) {
	this.price = this.price+price;
}

public Integer getPrice() {
	return price;
}

public void setPrice(Integer price) {
	this.price = price;
}


}

person1

package com.yuxuan.j2se;

public class Person1 implements Runnable{
private Account account;

public Person1(Account account) {
	super();
	this.account = account;
}

@Override
public void run() {
synchronized (account) {
	
	System.out.println("person1原account价格"+account.getPrice());
	account.addPrice(100);
	System.out.println("person1存入100acount后,account价格"+account.getPrice());
	try {
		
		Thread.currentThread().sleep(5000);
		
		System.out.println("person1睡了5秒后,account价格"+account.getPrice());
		
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

	
	
}

}

Person2

package com.yuxuan.j2se;

public class Person2 implements Runnable{
private Account account;

public Person2(Account account) {
	super();
	this.account = account;
}

@Override
public void run() {
	synchronized (account) {
		
		System.out.println("person2原account价格"+account.getPrice());
		account.addPrice(200);
		System.out.println("person2存入200后,account价格"+account.getPrice());
		try {
			
			Thread.currentThread().sleep(3000);
			System.out.println("person2睡3秒后,accout价格"+account.getPrice());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	
}

}

person3

package com.yuxuan.j2se;

public class Person3 implements Runnable{
private Account account;

public Person3(Account account) {
	super();
	this.account = account;
}

@Override
public void run() {
	synchronized (account) {
		
		System.out.println("person3原account价格"+account.getPrice());
		account.deductPrice(200);
		System.out.println("person3扣除200后，account价格"+account.getPrice());
		try {
			
			Thread.currentThread().sleep(5000);
			System.out.println("person3睡5秒后，account价格"+account.getPrice());
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
	
}

}

Test

package com.yuxuan.j2se;

public class TestAccount {
 public static void main(String[] args) throws InterruptedException {
	Account account =  new Account();
	Thread thread1 = new Thread(new Person1(account));
	Thread thread2 = new Thread(new Person2(account));
	Thread thread3 = new Thread(new Person3(account));
	thread1.start();
	thread2.start();
	thread3.start();

}
}

你会看到像下面的输出

person1原account价格300
person1存入100acount后,account价格400
person1睡了5秒后,account价格400
person3原account价格400
person3扣除200后，account价格200
person3睡5秒后，account价格200
person2原account价格200
person2存入200后,account价格400
person2睡3秒后,accout价格400

上面没有看到什么不对的地方

而如果把Person1,person2,person3里面的

synchronized (account) {
}

去掉，改成如

public void run() {
	
		
		System.out.println("person3原account价格"+account.getPrice());
		account.deductPrice(200);
		System.out.println("person3扣除200后，account价格"+account.getPrice());
		try {
			
			Thread.currentThread().sleep(5000);
			System.out.println("person3睡5秒后，account价格"+account.getPrice());
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

你会看到像下面的输出，

person1原account价格300
person3原account价格300
person2原account价格300
person3扣除200后，account价格200
person1存入100acount后,account价格400
person2存入200后,account价格400
person2睡3秒后,accout价格400
person1睡了5秒后,account价格400
person3睡5秒后，account价格400

person3绝对很乐意这样做，300块，取出了200块，还剩200！这就是应为没加synchronized (account) {}

导致钱显示的不正确