Java 对象锁

最新推荐文章于 2023-06-21 16:41:40 发布
最新推荐文章于 2023-06-21 16:41:40 发布
阅读量858 收藏
点赞数
分类专栏： Java SE/EE相关 文章标签： Java 对象 多线程 线程

转自：点击打开原文链接

 

     在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。

1.对象的锁

所有对象都自动含有单一的锁。
JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。
只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。
每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。

2.synchronized同步块

2.1同步到单一对象锁

当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象  synchronized  ( this )），所以对它们的方法依然是互斥的。
  
package com.zj.lock;
import java.util.concurrent.TimeUnit;

public class Resource1 {
	public void f() {
		 // other operations should not be locked...
		System.out.println(Thread.currentThread().getName() + ":not synchronized in f()");
		synchronized (this) {
			for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName() + ":synchronized in f()");
				try {
					TimeUnit.SECONDS.sleep(3);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public void g() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in g()");       
		synchronized (this) {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in g()");                				try {                  
					TimeUnit.SECONDS.sleep(3);             
				} catch (InterruptedException e) {                  
					e.printStackTrace();            
  				}           
			}       
		}    
	}

	public void h() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in h()");       
		synchronized (this) {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in h()");             	 			try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		}    
	}

	public static void main(String[] args) {       
		final Resource1 rs = new Resource1();        
		new Thread() {           
			public void run() {              
				rs.f();           
			}       
		}.start();        
		new Thread() {           
			public void run() {              
				rs.g();           
			}       
		}.start();  
      
		rs.h();    
	}
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()

2.2 同步到多个对象锁

Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（ synchronized  ( this ) ， synchronized ( syncObject1 ) ， synchronized  ( syncObject2 )），所以对它们的方法中的临界资源访问是独立的。 

package com.zj.lock;
import java.util.concurrent.TimeUnit; 
public class Resource2 {    
	private Object syncObject1 = new Object();    
	private Object syncObject2 = new Object();     
	public void f() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in f()");       
		synchronized (this) {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in f()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		}    
	}     

	public void g() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in g()");       
		synchronized (syncObject1) {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in g()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		}    
	}     

	public void h() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in h()");       
		synchronized (syncObject2) {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in h()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		}    
	}     

	public static void main(String[] args) {       
		final Resource2 rs = new Resource2();        
		new Thread() {           
			public void run() {              
				rs.f();           
			}       
		}.start();        
		new Thread() {           
			public void run() {              
				rs.g();           
			}       
		}.start();
		        
		rs.h();    
	}
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()

3.Lock对象锁

除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。
  
package com.zj.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; 

public class Resource3 {    
	private Lock lock = new ReentrantLock();     
	public void f() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in f()");       
		lock.lock();       
		try {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in f()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		} finally {           
			lock.unlock();       
		}    
	}     

	public void g() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in g()");       
		lock.lock();       
		try {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in g()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		} finally {           
			lock.unlock();       
		}    
	}     
	
	public void h() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in h()");       
		lock.lock();       
		try {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in h()");             	 			try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		} finally {           
			lock.unlock();       
		}    
	}     
	public static void main(String[] args) {       
		final Resource3 rs = new Resource3();        
		new Thread() {           
			public void run() {              
				rs.f();           
			}       
		}.start();        
		new Thread() {           
			public void run() {              
				rs.g();           
			}       
		}.start();        

		rs.h();    
	}
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
 
  
package com.zj.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; 

public class Resource4 {    
	private Lock lock1 = new ReentrantLock();    
	private Lock lock2 = new ReentrantLock();    
	private Lock lock3 = new ReentrantLock();     
	public void f() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in f()");       
		lock1.lock();       
		try {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in f()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		} finally {           
			lock1.unlock();       
		}    
	}     

	public void g() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in g()");       
		lock2.lock();       
		try {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in g()");              				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		} finally {           
			lock2.unlock();       
		}    
	}
	     
	public void h() {       
		// other operations should not be locked...       
		System.out.println(Thread.currentThread().getName() + ":not synchronized in h()");       
		lock3.lock();       
		try {           
			for (int i = 0; i < 5; i++) {              
				System.out.println(Thread.currentThread().getName() + ":synchronized in h()");             				try {                  
					TimeUnit.SECONDS.sleep(3);              
				} catch (InterruptedException e) {                  
					e.printStackTrace();              
				}           
			}       
		} finally {           
			lock3.unlock();       
		}    
	}
     
	public static void main(String[] args) {       
		final Resource4 rs = new Resource4();        
		new Thread() {           
			public void run() {              
				rs.f();           
			}       
		}.start();        
		new Thread() {           
			public void run() {              
				rs.g();           
			}       
		}.start();        

		rs.h();    
	}
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()



4.synchronized和lock的区别:
Lock 的锁定是通过代码实现的，而 synchronized 是在 JVM 层面上实现的
synchronized 在锁定时如果方法块抛出异常，JVM 会自动将锁释放掉，不会因为出了异常没有释放锁造成线程死锁。但是 Lock 的话就享受不到 JVM 带来自动的功能，出现异常时必须在 finally 将锁释放掉，否则将会引起死锁。

在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。 

ReentrantLock: 
ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。 

Atomic: 
和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。 

 
MessCodes
关注
专栏目录
Java 多线程（2）---- 线程的控制
指点
03-12 1107
前言 在上一篇文章中我们简单的认识了一下线程。包括线程的优先级、如何创建一个线程（通过继承 Thread 类或者通过新建 Runnable 对象并作为参数传入 Thread 的构造方法中）、线程的声明周期状态（新建状态、运行状态（就绪状态、正在运行状态）、等待状态、阻塞状态、结束状态），最后我们看了一下守护线程的概念和其特点。如果你对线程的一些概念还不熟悉，建议先从第一篇文章看起：Java 多线...
java 对象锁_Java的对象锁
weixin_33623134的博客
02-12 1347
内置锁Java提供了一种内置的锁机制来支持原子性和可见性：同步代码块(Synchronized Block)。同步代码块包括两部分：一个是作为锁的对象引用，一个是锁保护的代码块。每一个Java对象都可以用做一个实现同步的锁，这种锁被称为内置锁(Intrinsic Lock)或者监视器锁(Monitor Lock)。线程进入同步代码块之前会自动获得锁，并且在退出同步代码块时(正常返回，或者是异常退出...
Java对象锁和类锁全面解析（多线程synchronized关键字）
weixin_30512043的博客
06-17 870
最近工作有用到一些多线程的东西，之前吧，有用到synchronized同步块，不过是别人怎么用就跟着用，并没有搞清楚锁的概念。最近也是遇到一些问题，不搞清楚锁的概念，很容易碰壁，甚至有些时候自己连用没用对都不知道。 今天把一些疑惑都解开了，写篇文章分享给大家，文章还算比较全面。当然可能有小宝鸽理解得不够深入透彻的地方，如果说得不正确还望指出。 看之前有必要跟某些猿友说一下，...
java多线程并发控制之锁
薛宇凡robin
11-19 6728
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1.对象的锁 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 每当任务离开一个synchronized方法，计数
Java线程并发控制基础知识
weixin_34356138的博客
05-20 89
微博上众神推荐今年4月刚刚出版的一本书，淘宝华黎撰写的《大型网站系统与Java中间件实践》，一线工程师的作品，实践出真知，果断要看。 前两章与《淘宝技术这十年》内容类似，基本是讲从一个小网站如何慢慢升级成分布式网站，从第三章开始亮出干货，个人感觉总结的很好，本文主要摘取并扩充下作者第三章的内容 作学习交流之用，非盈利性质 线程池、线程同步、互斥锁、读写锁、原子数、唤醒、通知、信号量、...
Java对象锁
qq_30242987的博客
03-15 391
Java对象锁和类锁全面解析（多线程synchronized关键字） 来源：http://www.importnew.com/20444.html
详解java 对象锁与类锁
09-07
Java中的对象锁与类锁是多线程编程中非常重要的概念，它们用于控制并发访问，确保数据的一致性和完整性。本文将深入探讨这两种锁的原理、形式及应用场景。 一、对象锁（方法锁） 对象锁，又称为实例锁，是针对特定...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
JAVA多线程的控制
Lullaby's Blog
03-28 2802
B/S结构的项目中有报表生成的处理，由于处理时间过长，采用多线程的方式做成。点击“报表生成”按钮提交多线程请求，服务端启动一个线程就立刻Response，提示客户到报表一览画面察看结果。原来对于客户端启用多线程并没有加以限制，实际运用中，客户可以不断的点击按钮提交线程请求，服务端就不断的生成子线程，有可能导致严重的后果。因此，考虑对客户端的请求加以限制，如果超过该机能的线程限制就必须等待，直到当前
java 对象锁 类锁_java类锁和对象锁
weixin_42617406的博客
02-12 2213
java对象锁有两种：对象锁、类锁。对象锁：在非静态方法上加锁。声明了一个对象锁。类锁：在静态方法上加锁，声明了一个类锁。经过大量的实验总结出以下结论：1、想要保证能够锁住对象，需要在对应的的普通方法上加上synchronized关键字。2、想要保证能够锁住对象，需要在对应的的普通方法上加上synchronized关键字。3、非静态函数用关键字synchronized不会对普通方法有影响。4、普通...
java 精灵线程_java 多线程 3 : 控制线程
weixin_39980360的博客
02-13 87
join线程：public class JoinThread extendsThread{publicJoinThread(String name) { super(name);}public voidrun() {for(int i = 0 ; i < 100 ; i++) {System.out.println(getName()+ " " +i);}}public static voi...
java 多线程 控制_java多线程（六）线程控制类
weixin_30348079的博客
02-12 275
1. 多线程控制类为了保证多线程的三个特性，Java引入了很多线程控制机制，下面介绍其中常用的几种：l ThreadLocall 原子类l Lock类l Volatile关键字1.1. ThreadLocal1.1.1. 作用ThreadLocal提供线程局部变量，即为使用相同变量的每一个线程维护一个该变量的副本。当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可...
java中方法锁定的机制,Java中对象的锁定机制
weixin_35628777的博客
03-14 73
假设客户有信用卡.并且他有x金额的余额并且他正在购买y值项目(y (y z> x但z Java解决方法:我更喜欢有一个ReadWriteLock,这有助于锁定它进行读写,这很好,因为你可以为每个资源分别进行读写锁定：ReadWriteLock readWriteLock = new ReentrantReadWriteLock();readWriteLock.readLock().lock(...
详解Java锁对象
最新发布
Krive~Irving
06-21 3239
synchronized特性,锁对象,volatile,
Java多线程控制
qijiqiguai的专栏
12-10 842
系统性解析Java中多线程的管理。这是很多并发编程的基础，也是JavaCurrent包的实现基础。
Java 多线程控制
陨落烟雨的博客
10-13 386
/** * 1,线程的名称,可以通过构造函数来初始化,或者setName * 2,线程的优先级,可以直接setPro * 3,sleep 阻塞状态,让出cpu * 4,join 合并线程,这里的合并指的是接上,编码效果上是顺序执行 * 5,isAlive 判断线程是否还活着 */public class ThreadControlMethod { public static vo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值