java.util.concurrent.locks与synchronized及其异同_在一个util.concurrent实例上使用synchronized-优快云博客

本文详细介绍了Java并发编程中synchronized和Lock锁的使用方法及两者之间的区别，包括同步机制、读写锁特性、中断处理等核心概念。通过对比分析，帮助读者理解如何在实际开发中灵活运用这些同步机制，提高代码并发安全性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

http://blog.youkuaiyun.com/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关键字

[java]view plaincopy 
   
 public synchronized void f() {  
 //do something  
 }  

2、synchronized同步代码块

[java]view plaincopy 
   
 synchronized (mutex) {  
 // do something  
 }  

对于这两种方式又应该着重区分是否为“ static ”的，因为static的成员是属于类的，非staitc的是属于具体实例的，所以在使用synchronized时应该注意方法或选择的同步变量是否为static的，如下代码：

[java]view plaincopy 
   
 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和ReentrantReadWriteLock

1、可重入的锁ReentrantLock

使用ReentrantLock锁最简单的一个例子：

[java]view plaincopy 
   
 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()方法源码介绍

[java]view plaincopy 
   
 public void lockInterruptibly() throws InterruptedException {  
     sync.acquireInterruptibly(1);  
 }  

a、首先lockInterruptibly调用了内部类sync的acquireInterruptibly(1)方法，这个sync就是前面提到的AbstractQueuedSynchronizer的子类

[java]view plaincopy 
   
 abstract static class Sync extends AbstractQueuedSynchronizer {  
     // ....  
 }  

[java]view plaincopy 
   
 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方法。

[java]view plaincopy 
   
 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，还有一个特别值得注意的地方，请看下面的代码：

[java]view plaincopy 
   
 Lock lock = new ReentrantLock();  
 // ....  
 try {  
     lock.lock();  
     lock.lock();  
     // do something...  
 } finally {  
     lock.unlock();  
 }  
 // ....  

可以看到上面，上面代码调用lock()方法和调用unlock()方法的次数不同，这样的一段代码执行完后，别的线程是否已经可以获取该lock锁呢？

[java]view plaincopy 
   
 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();  
                 }  
             }  
         }  
   
     }  
 }  

运行的结果:

[java]view plaincopy 
   
 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 线程同时保持，而写入锁定是独占的。下面通过一个简单的例子来了解它：

[java]view plaincopy 
   
 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