http://blog.csdn.net/smcwwh/article/details/7193666
关键字:synchronized、java.util.concurrent.locks.Lock、同步、并发、锁
一、【引言】
JDK1.5之前,实现同步主要是使用synchronized,而在JDK1.5中新增了java.util.concurrent包及其两个子包locks和atomic,其中子包locks中定义了系列关于锁的抽象的类。本文主要介绍java.util.concurrent.locks的使用及其与synchronized两种方式实现同步的异同。二、【synchronized同步】
synchronized相信很多熟悉J2SE的人都不会对这个关键字陌生,它用于实现多个线程之间的同步,一般有两种使用方式:1、在方法上加synchronized关键字
- public synchronized void f() {
- //do something
- }
- synchronized (mutex) {
- // do something
- }
- package test.lock;
- /**
- * @author whwang
- * 2012-1-10 下午11:19:04
- */
- public class SyncTest {
- private Object mutex = new Object();
- public synchronized void f1() {
- synchronized (mutex) {
- System.err.println("nonstatic method f1....");
- try {
- Thread.sleep(2 * 1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- public static void main(String[] args) {
- SycnThread thread1 = new SycnThread(new SyncTest());
- SycnThread thread2 = new SycnThread(new SyncTest());
- SycnThread thread3 = new SycnThread(new SyncTest());
- thread1.start();
- thread2.start();
- thread3.start();
- }
- }
- class SycnThread extends Thread {
- private SyncTest st;
- public SycnThread(SyncTest st) {
- this.st = st;
- }
- @Override
- public void run() {
- while (true) {
- st.f1();
- }
- }
- }
在main方法,创建thread1、2、3三个线程,它们都调用SyncTest的f1()方法,而方法f1()使用mutex(非static)来做同步变量,如果你的意图是实现这3个线程对方法f1的同步,那么运行的结果会让你大失所望,因为这样根本就无法使得这3个线程同步,原因在于:mutex是一个非static的成员变量,也就是说每new SyncTest(),它们的mutex变量都是不相同的。这样,对于上面这个程序来说,意味着每一个线程都使用了一个mutex来做它们各自的不同变量,如果希望上面3个线程同步,可以把mutex改为static或在创建SycnThread时,传入的SyncTest都为同一个对象即可。
还有当使用String常量或全局变量时都应该引起注意, Java线程同步小陷阱,你掉进去过吗? 。
三、【java.util.concurrent.locks下的锁实现同步】
自JDK1.5以为,Java提供了java.util.concurrent这个并发包,在它的子包locks中,提供了一系列关于锁的抽象的类。主要有两种锁ReentrantLockReentrantReadWriteLock,而其他的两个类,都是“辅助”类,如AbstractQueuedSynchronizer就是一个用于实现特殊规则锁的抽象类,ReentrantLock和ReentrantReadWriteLock内部都有一个继承了该抽象类的内部类,用于实现特定锁的功能。下文主要介绍:ReentrantLock和ReentrantReadWriteLock1、可重入的锁ReentrantLock
使用ReentrantLock锁最简单的一个例子:- Lock lock = new ReentrantLock();
- try {
- lock.lcok();
- // do something
- } finally {
- lock.unlock();
- }
上面这段代码,首先创建了一个lock,然后调用它的lock()方法,开启锁定,在最后调用它的unlock()解除锁定。值得注意的时,一般在使用锁时,都应该按上面的风格书写代码,即lock.unlock()最好放在finally块,这样可以防止,执行do something时发生异常后,导致锁永远无法被释放。
到此,还没发现Lock与synchronized有什么不同,Lock与synchronized不同之处主要体现在Lock比synchronized更灵活得多,而这些灵活又主要体现在如下的几个方法:
//lock()tryLock()
tryLock(long timeout, TimeUnit timeUnit)
lockInterruptibly()
//unlock()
A、 trylock()方法 :如果获取了锁立即返回true,如果别的线程正持有锁,立即返回false;
B、 tryLock(long timeout, TimeUnit timeUnit)方法 :如果获取了锁定立即返回true,如果别的线程正持有锁,会等待参数给定的时间,在等待的过程中,如果获取了锁定,就返回true,如果等待超时,返回false;
是不是比synchronized灵活就体现出来了,打个不是很恰当的比分:你现在正在忙于工作,突然感觉内急,于是你跑向洗手间,到门口发现一个“清洁中,暂停使用”的牌牌。没办法,工作又忙,所以你只好先放弃去洗手间回去忙工作,可能如此反复,终于你发现可以进了,于是......
像这样的场景用synchronized你怎么实现?没办法,如果synchronized,当你发现洗手间无法暂时无法进入时,就只能乖乖在门口干等了。而使用trylock()呢,首先你试着去洗手间,发现暂时无法进入(trylock返回false),于是你继续忙你的工作,如此反复,直到可以进入洗手间为止(trylock返回true)。甚至,你非常急,你可以尝试性的在门口等20秒,不行再去忙工作(trylock(20, TimeUnit.SECONDS);)。
C、 lockInterruptibly()方法
lockInterruptibly()方法的执行如下:
如果该锁定没有被另一个线程保持,则获取该锁定并立即返回,将锁定的保持计数设置为 1。
如果当前线程已经保持此锁定,则将保持计数加 1,并且该方法立即返回。
如果锁定被另一个线程保持,则出于线程调度目的,禁用当前线程,并且在发生以下两种情况之一以前,该线程将一直处于休眠状态:
a、锁定由当前线程获得;
b、或者其他某个线程中断当前线程。
如果当前线程获得该锁定,则将锁定保持计数设置为1。
如果当前线程:
a、在进入此方法时已经设置了该线程的中断状态;
b、或者在等待获取锁定的同时被中断。
则抛出 InterruptedException,并且清除当前线程的已中断状态。
即lockInterruptibly()方法允许在等待时由其它线程调用它的Thread.interrupt方法来中断等待而直接返回,这时不再获取锁,而会抛出一个InterruptedException。
D、lockInterruptibly()方法源码介绍
- public void lockInterruptibly() throws InterruptedException {
- sync.acquireInterruptibly(1);
- }
a、首先lockInterruptibly调用了内部类sync的acquireInterruptibly(1)方法,这个sync就是前面提到的AbstractQueuedSynchronizer的子类
- abstract static class Sync extends AbstractQueuedSynchronizer {
- // ....
- }
- public final void acquireInterruptibly(int arg)
- throws InterruptedException {
- if (Thread.interrupted())
- throw new InterruptedException();
- if (!tryAcquire(arg))
- doAcquireInterruptibly(arg);
- }
b、在sync的acquireInterruptibly方法中,首先检查当前现场是否已经中断,如果已经中断,抛出InterruptedException异常,否则调用调用sync的doAcquireInterruptibly方法。
- private void doAcquireInterruptibly(int arg)
- throws InterruptedException {
- final Node node = addWaiter(Node.EXCLUSIVE);
- boolean failed = true;
- try {
- for (;;) {
- final Node p = node.predecessor();
- if (p == head && tryAcquire(arg)) {
- setHead(node);
- p.next = null; // help GC
- failed = false;
- return;
- }
- // 抛出InterruptedException异常
- if (shouldParkAfterFailedAcquire(p, node) &&
- parkAndCheckInterrupt())
- throw new InterruptedException();
- }
- } finally {
- if (failed)
- cancelAcquire(node);
- }
- }
c、在sync的方法doAcquireInterruptibly中,关键在于检测到中断则直接退出循环(不在等待获取锁),而是直接抛出InterruptedException异常,最后在finally里调用cancelAcquire取消获锁操作。
E、除了这些方法之外,ReentrantLock还提供了很多实用的方法,这里就不再一一讲述
对于Lock,还有一个 特别值得注意 的地方,请看下面的代码:
- Lock lock = new ReentrantLock();
- // ....
- try {
- lock.lock();
- lock.lock();
- // do something...
- } finally {
- lock.unlock();
- }
- // ....
可以看到上面,上面代码调用lock()方法和调用unlock()方法的次数不同,这样的一段代码执行完后,别的线程是否已经可以获取该lock锁呢?
- package test.mult;
- import java.util.concurrent.locks.Lock;
- import java.util.concurrent.locks.ReentrantLock;
- /**
- * @ClassName: Test
- * @author whwang
- * @date 2012-1-11 下午02:04:04
- */
- public class Test {
- private String name;
- public Test(String name) {
- this.name = name;
- }
- public static void main(String[] args) {
- // 这样创建一个"公平竞争"的锁
- Lock lock = new ReentrantLock(true);
- MyThread t1 = new MyThread(lock, new Test("test1"));
- MyThread t2 = new MyThread(lock, new Test("test2"));
- t1.start();
- t2.start();
- }
- private static class MyThread extends Thread {
- Lock lock = null;
- Test test = null;
- public MyThread(Lock lock, Test test) {
- this.lock = lock;
- this.test = test;
- }
- @Override
- public void run() {
- while (true) {
- try {
- // 调用两次lock
- lock.lock();
- lock.lock();
- System.err.println(test.name + " locked...");
- try {
- Thread.sleep(3 * 1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- } finally {
- lock.unlock();
- }
- }
- }
- }
- }
运行的结果:
- test1 locked...
- test1 locked...
- test1 locked...
- test1 locked...
- test1 locked...
- test1 locked...
永远都是持有test1这个类的线程才能获取锁,其实是第一个获取锁的线程,他永远都拿着锁不放。
所以在使用Lock的时候,lock与unlock一定要 配对 。
2、可重入的读写锁ReentrantReadWriteLock
该锁的用法与ReentrantLock基本一样,只是ReentrantReadWriteLock实现了特殊规则(读写锁),在ReentrantReadWriteLock中有两个内部类ReentrantReadWriteLock.ReadLock和ReentrantReadWriteLock.WriteLock(实际上不止两个内部类,还有实现AbstractQueuedSynchronizer的Sync等等),这两个类分别可以使用ReentrantReadWriteLock的readLock()和writeLock()返回,该读写锁的规则是:只要没有writer,读取锁定可以由多个reader 线程同时保持,而写入锁定是独占的。下面通过一个简单的例子来了解它:- package test.mult;
- import java.util.concurrent.locks.ReentrantReadWriteLock;
- /**
- * @ClassName: ReadWriteLockTest
- * @author whwang
- * @date 2012-1-11 下午02:20:59
- */
- public class ReadWriteLockTest {
- static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
- public static void main(String[] args) {
- // 是否可以进入多个reader - 可以
- // 是否可以进入多个writer - 不可以
- // 当有reader进入后, writer是否可以进入 - 不可以
- // 当有writer进入后, reader是否可以进入 - 不可以
- MyThread t1 = new MyThread(0, "t1");
- MyThread t2 = new MyThread(0, "t2");
- MyThread t3 = new MyThread(1, "t3");
- t1.start();
- t2.start();
- t3.start();
- }
- private static class MyThread extends Thread {
- private int type;
- private String threadName;
- public MyThread(int type, String threadName) {
- this.threadName = threadName;
- this.type = type;
- }
- @Override
- public void run() {
- while (true) {
- if (type == 0) {
- // read
- ReentrantReadWriteLock.ReadLock readLock = null;
- try {
- readLock = lock.readLock();
- readLock.lock();
- System.err.println("to read...." + threadName);
- try {
- Thread.sleep(5 * 1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- } finally {
- readLock.unlock();
- }
- } else {
- // write
- ReentrantReadWriteLock.WriteLock writeLock = null;
- try {
- writeLock = lock.writeLock();
- writeLock.lock();
- System.err.println("to write...." + threadName);
- try {
- Thread.sleep(5 * 1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- } finally {
- writeLock.unlock();
- }
- }
- }
- }
- }
- }
3、AbstractQueuedSynchronizer:如果需要自己实现一些特殊规则的锁,可以通过拓展该类来实现。
参考文档:
http://wenku.baidu.com/view/41480552f01dc281e53af090.html
http://tutorials.jenkov.com/java-concurrency/index.html