`
huanggaole
  • 浏览: 10150 次
  • 性别: Icon_minigender_1
最近访客 更多访客>>
kenny_kiss
社区版块
存档分类
最新评论

使用synchronized和Lock对象获取对象锁

synchronizedjavalockthread 
阅读更多
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
1.对象的锁
    所有对象都自动含有单一的锁。
    JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。
    只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。
    每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。
2.synchronized同步块
    当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
    Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象 synchronized (this)），所以对它们的方法依然是互斥的。 


package cn.java.loak;

import java.util.concurrent.TimeUnit;

public class Resource1 {

	public void f(){
		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(){
	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(){
	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 同步到多个对象锁
    Resource2.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized (this)，synchronized (syncObject1)，synchronized (syncObject2)），所以对它们的方法中的临界资源访问是独立的。 
package cn.java.loak;

import java.util.concurrent.TimeUnit;

public class Resource2 {
	private Object syncObject1=new Object();
	private Object syncObject2=new Object();
	
	public void f(){
		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(){
		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(){
		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();
				}
			}
		}
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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 cn.java.loak;

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(){
		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(){
	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(){
	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-0synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0synchronized in f()
Thread-0synchronized in f()
Thread-0synchronized in f()
Thread-0synchronized in f()
mainsynchronized in h()
mainsynchronized in h()
mainsynchronized in h()
mainsynchronized in h()
mainsynchronized in h()
Thread-1synchronized in g()
Thread-1synchronized in g()
Thread-1synchronized in g()
Thread-1synchronized in g()
Thread-1synchronized in g() 

package cn.java.loak;

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(){
		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(){
		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(){
		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()
分享到：
| 创建线程的两种方式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Lock接口与synchronized关键字

    而Lock接口则是一个更底层的同步机制，它提供了更丰富的功能，但需要显式地获取和释放锁，通常通过实现类如ReentrantLock来使用。 其次，从功能特性上来看，synchronized具有可重入性，即同一个线程可以多次获取同...

    java的Lock锁原理详解.docx

    同样是锁，先说说synchronized和lock的...2.synchronized可以锁住代码块，对象和类，但是线程从开始获取锁之后开发者不能进行控制和了解；lock则用起来非常灵活，提供了许多api可以让开发者去控制加锁和释放锁等等。

    大厂真题之字节跳动-Java初级

    1、锁可以锁在哪里？ Java 为程序加锁的方式主要有两种：synchronized 与 Lock。 1. synchronized 可以修饰的作用域如下： - 非... 通过 Class 对象获取构造方法 3. 通过构造方法调用 newInstance()方法创建对象实例

    java关键字Synchronized详解

    此时，如果其他线程试图获取该对象的锁，JVM会将对象头中的Mark Word(指向对象头的指针)设置为偏向锁标识。这样，只有当前线程才能访问该对象，其他线程需要等待偏向锁失效后才能继续执行。 当一个线程释放偏向锁时...

    Java并发显式锁和显式条件队列

    　在类中利用synchronized修饰的方法或者this代码块，均使用的是类的实例锁或者类的锁。这些锁都称为内置锁。 　可以利用显式锁进行协调对象的访问。即ReentrantLock。这是一种可以提供无条件，可轮询，定时以及...

    java面试题进阶版附答案.docx

    三、线程同步和互斥锁：解释了线程同步的概念，以及互斥锁的作用，包括使用synchronized关键字和Lock接口实现线程同步的方式。 四、反射机制：解释了Java中的反射机制，包括在运行时动态获取类的信息，操作类的属性...

    超级有影响力霸气的Java面试题大全文档

    子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。...

    java笔试题大集合及答案（另附各大公司笔试题）

    它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，...

    java 面试题 总结

    子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。...

    Python使用functools实现注解同步方法

    在 Python 中没有类似 Java 中使用的 synchronized 关键字来同步方法，因此在 Python 中要实现同步方法，通常我们是使用 threading.Lock() 来实现。在进入函数的地方获取锁，出函数的时候释放锁，这样实现代码看起好...

    二十三种设计模式【PDF版】

    同样地，面向对象设计员也沿袭一些模式，像“用对象表示状态”和“修饰对象以便 于你能容易地添加/删除属性”等。一旦懂得了模式，许多设计决策自然而然就产生了。 我们都知道设计经验的重要价值。你曾经多少次有过...

    Java 7并发编程实战手册

    1.3　线程信息的获取和设置　5 1.4　线程的中断　9 1.5　线程中断的控制　11 1.6　线程的休眠和恢复　15 1.7　等待线程的终止　17 1.8　守护线程的创建和运行　20 1.9　线程中不可控异常的处理　24 1.10　...

    JAVA面试题最全集

    简述synchronized和java.util.concurrent.locks.Lock的异同 ？ 34.EJB规范规定EJB中禁止的操作有哪些？ 35.java除了8种基本类型外，在虚拟机里还有哪一种，有什么作用? 36.除了使用new关键字创建对象意外，试列举...

    Java常见面试题208道.docx

    54.synchronized 和 Lock 有什么区别？ 55.synchronized 和 ReentrantLock 区别是什么？ 56.说一下 atomic 的原理？ 四、反射 57.什么是反射？ 58.什么是 java 序列化？什么情况下需要序列化？ 59.动态代理是什么？...

    Java并发编程实战

    13.4　在synchronized和ReentrantLock之间进行选择234 13.5　读-写锁235 第14章　构建自定义的同步工具238 14.1　状态依赖性的管理238 14.1.1　示例：将前提条件的失败传递给调用者240 14.1.2　示例：通过轮询与休眠...

    oscache-2.4.1-full.rar

    网上对于OSCache缓存Web页面很多说明和例子，但对于缓存对象方面说得不多，我就把自已写得一些东西放出来，让大家看一看是怎样缓存对象的! 我基于GeneralCacheAdministrator类来写的BaseCache类 view plaincopy...

    JAVA入门1.2.3：一个老鸟的JAVA学习心得 PART1（共3个）

    第6章 Java的类（Class）和对象（Object） 132 教学视频：59分钟 6.1 驾驶汽车向类（Class）的世界进发 132 6.1.1 汽车带来的问题 132 6.1.1 类的组成 134 6.1.3 使用自定义的Car类 136 6.1.4 类和对象 139 ...

    Java入门1·2·3：一个老鸟的Java学习心得.PART3（共3个）

    第6章 Java的类（Class）和对象（Object） 132 教学视频：59分钟 6.1 驾驶汽车向类（Class）的世界进发 132 6.1.1 汽车带来的问题 132 6.1.1 类的组成 134 6.1.3 使用自定义的Car类 136 6.1.4 类和对象 139 ...

    千方百计笔试题大全

    77、简述synchronized和java.util.concurrent.locks.Lock的异同 ？ 18 78、abstract class Name { private String name; public abstract boolean isStupidName(String name) {}}这有何错误? 18 79、public class ...

    java8源码-JavaSE-Code:JavaSE的代码练习与学习笔记总结

    java8 源码 Java SE 的代码与笔记 [ReadMe部分没有代码,代码都在项目文件中] ...哪个线程先执行带有synchronized关键字的方法,哪个对象就拥有该方法所属对象的锁Lock 当A线程调用anyObject对象加入syn

Magicbox
Global site tag (gtag.js) - Google Analytics