深入理解 Java 中的 synchronized 代码块

于 2024-06-15 17:11:30 发布
阅读量704 收藏 29
点赞数 24
分类专栏： Java 文章标签： java 开发语言 eclipse jvm java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74268571/article/details/139704557
版权

目录

前言

一、synchronized的工作原理

二、使用synchronized代码块的场景

三、编写synchronized代码块的最佳实践

四、何时使用 synchronized 代码块？

同步：

不同步：

五、Demo讲解

1.使用synchronized代码块减小锁的粒度，提高性能

2.synchronized可以使用任意的object进行加锁

 3.不要使用String的常量加锁，会出现死循环问题

4.锁对象的改变问题

5.死锁问题  

前言

        在多线程编程中，确保共享资源的安全访问是一个关键问题。Java 提供了多种机制来实现线程同步，其中 synchronized 关键字是最常用的一种。在本文中，我们将深入探讨 synchronized 代码块的使用和原理，并通过示例展示其应用。

一、synchronized的工作原理

synchronized关键字可以应用于方法或代码块，以确保同一时间只有一个线程可以执行被synchronized修饰的代码。其工作原理主要基于Java对象头中的Monitor（监视器）。每个Java对象都有一个与之关联的Monitor，线程在访问synchronized代码块时，需要首先获得该对象的Monitor的所有权。

  • synchronized方法：当一个线程进入一个对象的synchronized(this)方法时，它自动获取该对象的Monitor的所有权，并在方法返回或抛出异常时释放Monitor。
  • synchronized代码块：synchronized代码块允许我们更精细地控制哪些代码需要被同步。线程在访问synchronized(object)代码块时，需要获得指定对象object的Monitor的所有权。

二、使用synchronized代码块的场景

  • 保护共享资源：当多个线程需要访问和修改同一份数据时，可以使用synchronized代码块来确保同一时间只有一个线程能够访问这些数据。
  • 避免死锁：与synchronized方法相比，synchronized代码块提供了更细粒度的同步控制，有助于减少死锁的风险。通过只同步必要的代码段，可以减少线程之间的竞争和等待时间。
  • 提高性能：在某些情况下，使用synchronized代码块可以避免不必要的同步开销。例如，当一个方法中的大部分代码都不需要同步时，可以将需要同步的代码段封装在synchronized代码块中。

三、编写synchronized代码块的最佳实践

  • 尽量减小同步范围：只将需要同步的代码段放在synchronized代码块中，避免不必要的同步开销。
  • 避免在同步块中调用可能阻塞的方法：在同步块中调用可能阻塞的方法（如IO操作、等待用户输入等）会导致其他等待Monitor的线程也被阻塞，从而降低系统的并发性能。
  • 注意锁的粒度：过细的锁粒度可能导致线程之间的竞争加剧，而过粗的锁粒度则可能导致不必要的同步开销。因此，在选择锁的粒度时需要权衡这两个因素。
  • 避免嵌套锁：尽量避免在一个已经持有某个对象Monitor的线程中再次请求该对象或其他对象的Monitor。这可能导致死锁或其他并发问题。
  • 考虑使用ReentrantLock等高级并发工具：虽然synchronized关键字简单易用，但在某些复杂场景下可能需要更灵活的同步控制。此时可以考虑使用Java并发包中的ReentrantLock、Semaphore等高级并发工具。

四、何时使用 synchronized 代码块？

同步：

  1. 访问共享资源：当多个线程需要访问同一个对象或变量时，应该使用同步。
  2. 修改共享状态：当多个线程修改同一个对象的状态时，应该使用同步。
  3. 执行原子操作：当需要保证某些操作的原子性（即操作不可分割）时，应该使用同步。

不同步：

  1. 只读操作：如果多个线程只是读取共享资源，而不修改它，不需要同步。
  2. 局部变量：局部变量是线程私有的，不需要同步。
  3. 无共享资源：如果多个线程操作的资源相互独立，不需要同步。

五、Demo讲解

1.使用synchronized代码块减小锁的粒度，提高性能

使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同步的方法执行一个很长时间的任务，那么B线程就必须等待比较长的时间才能执行，这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁的粒度。

package com.ctb.sync6;

/**
 * 使用synchronized代码块减小锁的粒度，提高性能
 * 
 * @author biao
 *
 * 2024年
 */
public class Optimize {

	public void doLongTimeTask(){
		try {
			
			System.out.println("当前线程开始：" + Thread.currentThread().getName() + 
					", 正在执行一个较长时间的业务操作，其内容不需要同步");
			Thread.sleep(2000);
			
			synchronized(this){
				System.out.println("当前线程：" + Thread.currentThread().getName() + 
					", 执行同步代码块，对其同步变量进行操作");
				Thread.sleep(1000);
			}
			System.out.println("当前线程结束：" + Thread.currentThread().getName() +
					", 执行完毕");
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		final Optimize otz = new Optimize();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				otz.doLongTimeTask();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				otz.doLongTimeTask();
			}
		},"t2");
		t1.start();
		t2.start();
		
	}
	
	
}

结果： 

注：使用 synchronized 代码块减小锁的粒度，以提高多线程程序的性能。在 doLongTimeTask() 方法中，通过将长时间业务操作与需要同步的操作分别放置在不同的代码块中，两个线程可以更有效地并发执行需要同步的操作，可以减小锁的粒度，使得只有在必要的部分才会被同步，从而提高了并发执行的效率。

这样做的好处是在确保线程安全的同时，尽量减少同步的范围，避免不必要的阻塞，从而提升程序的性能。也是多线程编程中常用的优化手段之一

2.synchronized可以使用任意的object进行加锁

package com.ctb.sync6;

/**
 * 使用synchronized代码块加锁,比较灵活
 * 
 * @author biao
 *
 * 2024年
 */
public class ObjectLock {

	public void method1(){
		synchronized (this) {	//对象锁
			try {
				System.out.println("do method1..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void method2(){		//类锁
		synchronized (ObjectLock.class) {
			try {
				System.out.println("do method2..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	private Object lock = new Object();
	public void method3(){		//任何对象锁
		synchronized (lock) {
			try {
				System.out.println("do method3..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	public static void main(String[] args) {
		
		final ObjectLock objLock = new ObjectLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				objLock.method1();
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				objLock.method2();
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				objLock.method3();
			}
		});
		
		t1.start();
		t2.start();
		t3.start();
		
		
	}
	
}

结果： 

 注：在多线程环境下使用 synchronized 代码块来实现不同类型锁的加锁操作，通过展示对象锁、类锁和任意对象锁的使用方式，说明了不同加锁方式在多线程并发环境中的作用，用法比较灵活。

 3.不要使用String的常量加锁，会出现死循环问题

package com.ctb.sync6;
/**
 * synchronized代码块对字符串的锁，注意String常量池的缓存功能
 * 
 * @author biao
 *
 * 2024年
 */
public class StringLock {

	public void method() {
		//new String("字符串常量")
		synchronized ("字符串常量") {
			try {
				while(true){
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
					Thread.sleep(1000);		
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		final StringLock stringLock = new StringLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				stringLock.method();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				stringLock.method();
			}
		},"t2");
		
		t1.start();
		t2.start();
	}
}

 结果：

注：在 StringLock 类中，定义了一个 method() 方法，该方法使用 "字符串常量" 作为锁对象来实现同步操作。在方法中，通过 synchronized("字符串常量") 来对代码块进行加锁，确保多个线程在执行该代码块时是互斥的。

在 main 方法中，创建了两个线程 t1 和 t2 分别执行 method() 方法。由于两个线程共享同一个字符串常量作为锁对象，因此它们在执行 method() 方法时会相互竞争这个锁。  

public void method() {
		//new String("字符串常量")
		synchronized (new String("字符串常量")) {
			try {
				while(true){
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
					Thread.sleep(1000);		
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

 结果：

注：“字符串常量”它是只有一个引用，尽量不要拿字符串常量这种方式去加锁，我们可以使用new String("字符串常量")，注意即可  

4.锁对象的改变问题

当使用一个对象进行加锁的时候，要注意对象本身发生改变的时候，那么持有的锁就不同，如果对象本身不发生改变，那么依然是同步的，即使是对象的属性发生了改变。  

package com.ctb.sync6;
/**
 * 锁对象的改变问题
 * 
 * @author biao
 *
 * 2024年
 */
public class ChangeLock {

	private String lock = "lock";
	
	private void method(){
		synchronized (lock) {
			try {
				System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
				lock = "change lock";
				Thread.sleep(2000);
				System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
	
		final ChangeLock changeLock = new ChangeLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				changeLock.method();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				changeLock.method();
			}
		},"t2");
		t1.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
}

结果：

注：当我们使用字符串常量作为一把锁的时候，一定要注意在synchronized代码块里尽量不要去修改该锁对象的内容，第一个线程拿到的锁lock的值是lock，第二个线程拿到的是change lock去获得锁  

private void method(){
		synchronized (lock) {
			try {
				System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
				//lock = "change lock";
				Thread.sleep(2000);
				System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

结果：

注：//lock = "change lock";当我们不去修改该锁对象的内容时，他将会依次去获取锁。  

package com.ctb.sync6;
/**
 * 同一对象属性的修改不会影响锁的情况
 * 
 * @author biao
 *
 * 2024年
 */
public class ModifyLock {
	
	private String name ;
	private int age ;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public synchronized void changeAttributte(String name, int age) {
		try {
			System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 开始");
			this.setName(name);
			this.setAge(age);
			
			System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 修改对象内容为： " 
					+ this.getName() + ", " + this.getAge());
			
			Thread.sleep(2000);
			System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 结束");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		final ModifyLock modifyLock = new ModifyLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				modifyLock.changeAttributte("张三", 20);
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				modifyLock.changeAttributte("李四", 21);
			}
		},"t2");
		
		t1.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
}

 结果：

注：由于 changeAttribute 方法使用了对象锁，因此在多线程环境下，只有一个线程能够执行该方法，保证了对同一个对象的属性修改操作是互斥的。一个对象里面的属性发生改变的时候，是不影响锁的变化的，还是这个对象。

使用对象锁实现了对同一对象属性的修改操作的线程安全性，确保了多线程环境下对对象属性的修改操作是同步的，避免了数据不一致的情况发生  

5.死锁问题  

package com.ctb.sync6;

/**
 * 死锁问题，在设计程序时就应该避免双方相互持有对方的锁的情况
 * 
 * @author biao
 *
 * 2024年
 */
public class DeadLock implements Runnable{

	private String tag;
	private static Object lock1 = new Object();
	private static Object lock2 = new Object();
	
	public void setTag(String tag){
		this.tag = tag;
	}
	
	@Override
	public void run() {
		if(tag.equals("a")){
			synchronized (lock1) {
				try {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock1执行");
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lock2) {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock2执行");
				}
			}
		}
		if(tag.equals("b")){
			synchronized (lock2) {
				try {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入了lock2执行");
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lock1) {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入了lock1执行");
				}
			}
		}
	}
	
	public static void main(String[] args) {
		
		DeadLock d1 = new DeadLock();
		d1.setTag("a");
		DeadLock d2 = new DeadLock();
		d2.setTag("b");
		 
		Thread t1 = new Thread(d1, "t1");
		Thread t2 = new Thread(d2, "t2");
		 
		t1.start();
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	

	
}

 结果：

注：在 run() 方法中，如果 tag 的取值为 "a"，则线程会先获取 lock1，然后尝试获取 lock2；如果 tag 的取值为 "b"，则线程会先获取 lock2，然后尝试获取 lock1。

当两个线程同时运行时，它们会陷入死锁状态，因为彼此持有对方需要的锁而无法释放，导致程序无法继续执行下去，最终需要手动终止程序。

为避免死锁，应该设计程序避免多个线程竞争多个锁的情况，或者确保多个锁的获取顺序是一致的，从而避免循环等待的情况发生。  

孤留光乩
关注
  • 24
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
（六）java并发编程--synchronized同步块
Xinghf
11-24 1949
虽然前面文章的一些实例中已经使用synchronized关键字来实现线程的同步，但还是需要好好的理解一下。 [TOC] java synchronized 关键字 synchronized实例方法 synchronized静态方法 实例方法中的同步块 静态方法中的同步块 java synchronized 实例(安全初始化模式实例) java并发应用程序
深入理解java中的synchronized关键字
09-04
- 如果一个线程在一个对象的`synchronized(this)`块中，其他线程仍然可以访问该对象的非`synchronized(this)`代码块。 - 对象锁仅适用于该对象的`synchronized`代码块，不影响其他线程对其他对象的访问。 以下是...
Java中的synchronized(同步代码块与同步方法)
zkc_home
02-27 186
代码实例如下： package runnable; import java.math.BigDecimal; public class ThreadDemo { public static void main(String[] args) { SynObject synObject=new SynObject(); test te...
Java 多线程 —— 同步代码块（解决线程安全问题)(1)，2024年最新HR的话扎心了
最新发布
04-17 575
同步方法是属于对象，而在这个类里面调用方法的是this对象，也就是this.sellTicket()，因此把this提取出来作为对象锁中的对象。这样多个线程都用的是this锁。System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");
java 同步块(Java Synchronized Blocks)
weixin_30307267的博客
06-27 94
java 同步块(Java Synchronized Blocks) Java 同步块包括方法同步和代码块同步。java 同步可以避免资源竞争，避免死锁。 主题包括的主要内容: synchronized关键字Synchronized 实例方法Synchronized static methodsSynchronized blocks in instance methodsSynch...
java中的synchronized实例（代码块）
淡泊明志，宁静致远
06-19 942
上篇博客中简短的回顾了一下基础知识，这篇博客看看不同类型的实例
java线程同步代码块_线程间的同步与通信(1)——同步代码块Synchronized
weixin_26824299的博客
02-26 348
前言同步代码块(Synchronized Block) 是java中最基础的实现线程间的同步与通信的机制之一，本篇我们将对同步代码块以及监视器锁的概念进行讨论。什么是同步代码块(Synchronized Block)同步代码块简单来说就是将一段代码用一把锁给锁起来, 只有获得了这把锁的线程才访问, 并且同一时刻, 只有一个线程能持有这把锁, 这样就保证了同一时刻只有一个线程能执行被锁住的代码.这里...
synchronized方法和代码块
weixin_43808717的博客
10-23 2457
同步 由于多线程并发存在数据不安全问题，为了保证数据的安全性需要一些特殊的手段来维持。数据不安全主要是针对修改来说的，如果一个数据只能读不能修改几乎不会产生什么安全问题。只有修改数据的时候容易产生一些差错导致多线程并发造成数据不安全。 从操作系统的角度来看多线程访问临界资源时并且对临界资源做一定的修改就会产生错误，操作系统为了保证临界资源的安全性，保证每次访问临界资源的线程有且只有一个。多线程访问时会进入等待队列依次排队等待。 Java多线程并发出现数据不安全问题的原因也大致相同，因为某些操作不是原
Java中synchronized正确使用方法解析
08-25
本文将详细介绍 Java 中 synchronized 的正确使用方法，通过示例代码和实践案例，帮助读者深入理解 synchronized 的使用方法和原理。 一、并行和锁 并行是一种提高程序效率的方式，它允许多个线程同时执行，提高...
深入理解Java并发之synchronized实现原理.docx
06-27
在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，...
深入理解Java中的volatile关键字（总结篇）
08-26
深入理解Java中的volatile关键字 Java中的volatile关键字是一个非常重要的概念，它不仅仅在Java语言中有，在很多语言中都有的，而且其用法和语义也都是不尽相同的。volatile关键字的主要作用是提供可见性、原子性和...
java中synchronized（同步代码块和同步方法）详解及区别
08-31
主要介绍了 java中synchronized（同步代码块和同步方法）详解及区别的相关资料,需要的朋友可以参考下
深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
08-28
深入理解Java内置锁(synchronized)和显式锁(ReentrantLock) Java中有两种锁机制：内置锁（synchronized）和显式锁（ReentrantLock）。内置锁是Java语言提供的一种同步机制，使用synchronized关键字声明的方法或...
synchronized块（方法）的探索
leafdown_的博客
06-13 257
例： public class Try implements Runnable{ public void run() { synchronized(this) { for(int i=0;i<4;i++) { System.out.println(Thread.currentThread().getName()+" : "+i); } ...
Java多线程-synchronized同步方法及同步块简述
见证自己学习,成长的记录
09-07 1449
synchronized是隐示锁,出了作用域自动释放(同步方法或者同步代码块),Lock是手显示锁(手动加锁和释放锁,lock和unLock,别忘记关闭锁,不然可能造成死锁)队列+锁 synchronized 两种用法synchronized方法和synchronized块。
一文彻底理解synchronized（通俗易懂的synchronized）
fu_bobo
09-22 4040
一文搞懂synchronized
synchronized 怎么使用
shenshizhong的专栏
01-01 1234
synchronized 的使用
java synchronized关键字修饰代码块的使用
m0_51758445的博客
08-23 2682
java synchronized关键字修饰代码块的使用
Java中Synchronized的四种用法
Isonion的博客
08-24 4170
java中Synchronized的四种用法，修饰代码块、修饰方法、修饰静态方法、修饰类
【多线程与高并发原理篇：4_深入理解synchronized】.doc
07-09
`synchronized`关键字用于定义临界区，确保在同一时刻只有一个线程能够执行特定的代码块。临界区通常包括对共享资源的读写操作。如示例所示，一个简单的计数器类`SyncDemo`，其中的`counter`变量如果没有被同步保护...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值