`
huanggaole
  • 浏览: 10479 次
  • 性别: 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()
分享到：
| 创建线程的两种方式
评论
发表评论

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

相关推荐

    Synchronized 和 Lock 的区别和使用场景

    本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...

    synchronized枷锁实例

    对象锁是针对类的实例对象而言的，当一个线程访问某个对象的非静态 synchronized 方法或同步代码块时，会获取到该对象的锁。这种锁确保了同一时间只有一个线程能访问该对象的成员变量。例如： ```java public class...

    并发编程之synchronized&Lock&AQS详解(1)1

    `synchronized`在JVM层面是基于监视器锁(Monitor)实现的，依赖于操作系统的Mutex lock（互斥锁），早期版本性能较低，但1.5以后通过一系列优化，如锁粗化、锁消除、轻量级锁、偏向锁和自旋锁等，性能得到了显著提升...

    Synchronized与Lock

    ReentrantLock支持公平锁和非公平锁的选择，公平锁保证按照等待时间顺序获取锁，而非公平锁则可能让等待时间短的线程优先获得锁。Lock还提供了一些synchronized不具备的功能，比如： 1. 可以尝试获取锁，即tryLock...

    关于synchronized、Lock的深入理解

    1. **使用方式**：`synchronized`是隐式同步，无需手动释放，而`Lock`是显式同步，需手动调用`lock()`和`unlock()`。 2. **控制能力**：`Lock`提供了更多控制选项，如可中断、可选择公平性、锁分离等。 3. **异常...

    [并发并行]_[初级]_[C++实现sychronized方式的对象锁]

    除了`std::lock_guard`，还可以使用`std::unique_lock`，它提供了更多的灵活性，比如可以手动解锁或者尝试不阻塞地获取锁。 C++还提供了一些其他的同步工具，如`std::condition_variable`（条件变量），它允许线程...

    Lock接口与synchronized关键字

    - **synchronized**支持可重入性，即同一个线程可以多次获取同一个对象的锁，而不会导致死锁。 - **Lock**接口也提供了可重入锁的实现。 2. **灵活性**： - **Lock**接口提供了更多的灵活性，例如： - 可以尝试...

    synchronized 的理解

    `wait()`方法使当前线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用`notify()`或`notifyAll()`方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。 ```java synchronized (lock) { // ...

    Synchronized关键字的用法

    - 这种情况下，通常的做法是将该状态变量声明为一个对象，并在需要同步的地方使用这个对象作为锁。 - 示例： ```java private final Object lock = new Object(); public void updateStatus() { ...

    Java线程之锁对象Lock-同步问题更完美的处理方式代码实例

    在使用Lock对象时，需要注意锁的获取和释放。Lock对象可以使用lock()方法来获取锁，并使用unlock()方法来释放锁。在finally块中释放锁可以确保锁最终被释放，即使发生异常情况。 Lock对象也可以用来实现读写锁...

    java 多线程synchronized互斥锁demo

    2. **同步代码块**：指定一个对象作为监视器，只有获取到该对象锁的线程才能执行代码块： ```java Object lock = new Object(); public void sharedMethod() { synchronized(lock) { // 代码块 } } ``` 在...

    Java synchronized关键字和Lock接口实现原理

    Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发...但是，synchronized 关键字和 Lock 接口的实现原理和使用方法是不同的。

    Lock、Synchoronized和ReentrantLock的使用

    Synchronized 的优点是易于使用和理解，编译器通常会对其进行优化，可以提高性能。然而，Synchronized 也有一些缺点，如它不能被Interrupt，且在资源竞争激烈的情况下性能会下降。 二、ReentrantLock ...

    第15讲 synchronized和ReentrantLock有什么区别呢？1

    除了了解基本使用和案例外，深入理解它们的底层实现，如锁膨胀、降级，以及轻量级锁、重量级锁、自旋锁和偏斜锁等概念，对于成为一个合格的Java并发开发者至关重要。同时，掌握java.util.concurrent.locks包中的其他...

    深入Synchronized和java.util.concurrent.locks.Lock的区别详解

    使用Lock时，程序员需要显式地调用lock()来获取锁，并在finally块中确保调用unlock()来释放锁，这增加了代码的复杂性，但也带来了更高的控制度。Lock的优势在于它支持更细粒度的锁控制，可以提高并发性能，因为它...

    java 锁 Lock接口详解.docx

    4. **状态查询**：`synchronized`无法检查是否已获取锁，而`Lock`的`isHeldByCurrentThread()`和`isLocked()`方法可以查询锁的状态。 在使用`Lock`时，需要注意手动释放锁，避免死锁。`Lock`的`unlock()`方法必须在...

    Java synchronized详细解读.docx

    对于静态(`static`)方法，`synchronized`关键字锁定的是类的Class对象，因此，无论有多少个类的实例，所有线程在访问静态同步方法时都需要获取类的Class对象锁。这意味着，即使有多个类实例，所有线程也无法同时执行...

    ReentrantLock 与 synchronized 简介

    - **可中断等待**：通过`lock.tryLock()`和`lock.tryLock(long timeout, TimeUnit unit)`方法，可以在等待获取锁时响应中断。 - **锁共享**：`ReentrantLock`支持共享锁，允许多个线程同时获取锁，这对于读多写少...

    Java对象锁和类锁全面解析（多线程synchronize

    Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...

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