Java中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之间同步。 
Lock的使用参见下面的代码(把lock换成synchronized的效果是一样的):
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();
	}
}

  • 1
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronizedlock都是Java用来实现线程同步的关键字和类,它们的主要区别如下: 1. 锁的获取和释放方式不同 synchronized关键字是隐式锁,在代码块或方法使用时,当线程进入同步代码块时,会自动获取锁,执行完同步代码块后,会自动释放锁。而lock是显式锁,需要手动获取锁和释放锁,即通过lock()方法获取锁,通过unlock()方法释放锁。 2. 锁的可重入性不同 synchronized是可重入锁,即同一个线程在持有锁的情况下,能够再次获得该锁。而lock在获取锁时需要先判断当前线程是否已经持有锁,如果是,则允许该线程继续获取锁,也就是说,lock也是可重入锁。 3. 锁的公平性不同 synchronized是非公平锁,即线程在等待锁时,是随机竞争锁的。而lock可以通过构造函数指定锁的公平性,即fair为true时为公平锁,fair为false时为非公平锁。 4. 锁的灵活性不同 synchronized是内置的Java关键字,不能对其进行扩展。而lock是一个接口,可以通过实现该接口来扩展锁的功能,例如可以实现可断锁或超时锁等。 5. 锁的性能不同 synchronizedJava内置的锁,由JVM实现,JVM可以对其进行优化,锁的性能较高。而lock是基于Java API实现的锁,通常比synchronized稍微慢一些。 总之,synchronizedlock都是Java用来实现线程同步的关键字和类,它们各有优缺点,应根据具体场景选择使用哪种锁。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值