java中的synchronized和Lock

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。

java.util.concurrent.locks包下常用的类

首先，我们先看一下Lock接口的API：

public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); }

lock()：该方法用来获取锁。 如下：

Lock lock = new ReentrantLock(); lock.lock(); try { System.out.println(t.getName()+"获得了锁"); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(t.getName()+"释放了锁"); lock.unlock(); }

注意：在finally块中释放锁，目的是保证锁一定会被释放，防止死锁的发生。 不要将获取锁的过程写在try块中，因为如果在获取锁（自定义锁的实现）时发生了异常，异常抛出的同时，也会导致锁无故释放。

lockInterruptibly()：可中断地获取锁，和lock()方法不同的是该方法会响应中断，即在锁的获取中可以中断当前线程。 如，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B处于等待中，对线程B调用threadB.interrupt()会中断线程B的等待过程。 注意：当一个线程获取了锁之后，是不会被interrupt()方法中断的。只能中断阻塞中的线程。

tryLock()：尝试非阻塞的获取锁，调用该方法后立刻返回，如果能够获取则返回true，否则返回false。 一般如下格式：

Lock lock = new ReentrantLock(); if(lock.tryLock()) { try { System.out.println(t.getName()+"获得了锁"); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); System.out.println(t.getName()+"释放了锁"); } }else { System.out.println(t.getName()+"获得锁失败"); }

tryLock(long time, TimeUnit unit)：超时的获取锁，当前线程在以下3种情况下会返回： ① 当前线程在超时时间内获得了锁 ② 当前线程在超时时间内被中断 ③ 超时时间结束，返回false

可重入锁

重入锁ReentrantLock，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁还支持获取锁时的公平和非公平性选择，这里我们对公平性不细说。

其实synchronized关键字支持的锁也是重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。比如：当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

class Test{ public synchronized void method1() { method2(); } public synchronized void method2() { } }

假若synchronized不具备可重入性，此时线程A在method1方法中调用method2方法时，需要重新申请锁，这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。

public class TestLock { Lock lock = new ReentrantLock(); public static void main(String[] args) { final TestLock tl = new TestLock(); new Thread() { @Override public void run() { tl.insert(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { tl.insert(Thread.currentThread()); } }.start(); } public void insert(Thread t) throws InterruptedException { lock.lock(); try { System.out.println(t.getName()+"获得了锁"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(t.getName()+"释放了锁"); lock.unlock(); } } }

输出结果： Thread-0获得了锁 Thread-0释放了锁 Thread-1获得了锁 Thread-1释放了锁

public class TestLock { Lock lock = new ReentrantLock(); public static void main(String[] args) { final TestLock tl = new TestLock(); new Thread() { @Override public void run() { tl.test(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { tl.test(Thread.currentThread()); } }.start(); } public void test(Thread t) { if(lock.tryLock()) { try { System.out.println(t.getName()+"获得了锁"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); System.out.println(t.getName()+"释放了锁"); } }else { System.out.println(t.getName()+"获得锁失败"); } } }

输出结果： Thread-0获得了锁 Thread-1获得锁失败 Thread-0释放了锁

public class TestLock { Lock lock = new ReentrantLock(); public static void main(String[] args) { final TestLock tl = new TestLock(); Thread t1 = new Thread(new MyThread(tl)); Thread t2 = new Thread(new MyThread(tl)); t1.start(); t2.start(); t2.interrupt(); } public void insert(Thread t) throws InterruptedException { lock.lockInterruptibly();//该方法会响应中断获取锁 try { System.out.println(t.getName()+"获得了锁"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(t.getName()+"释放了锁"); lock.unlock(); } } } class MyThread implements Runnable{ TestLock tl; public MyThread(TestLock tl) { this.tl = tl; } @Override public void run() { try { tl.insert(Thread.currentThread()); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"被中断"); } } }

输出结果： Thread-0获得了锁 Thread-1被中断 Thread-0释放了锁

ReadWriteLock也是一个接口，它表示读写锁。里面有2个方法，一个用来获取读锁，一个用来获取写锁，ReentrantReadWriteLock是ReadWriteLock的实现类。

下面来看一下读写锁的具体用法，假如多个线程同时进行读操作，看一下synchronized的效果：

public class TestReadWriteLock { public static void main(String[] args) { final TestReadWriteLock trw = new TestReadWriteLock(); new Thread() { @Override public void run() { trw.get(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { trw.get(Thread.currentThread()); } }.start(); } public synchronized void get(Thread thread) { long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start <= 1) { System.out.println(thread.getName()+"正在进行读操作"); } System.out.println(thread.getName()+"读操作完毕"); } }

输出结果： Thread-0正在进行读操作 Thread-0正在进行读操作 Thread-0正在进行读操作 … Thread-0读操作完毕 Thread-1正在进行读操作 Thread-1正在进行读操作 Thread-1正在进行读操作 … Thread-1读操作完毕

如果改成读写锁，效果如下：

public class TestReadWriteLock { ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); public static void main(String[] args) { final TestReadWriteLock trw = new TestReadWriteLock(); new Thread() { @Override public void run() { trw.get1(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { trw.get1(Thread.currentThread()); } }.start(); } public void get1(Thread thread) { lock.readLock().lock(); try { long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start <= 1) { System.out.println(thread.getName()+"正在进行读操作"); } System.out.println(thread.getName()+"读操作完毕"); } finally { lock.readLock().unlock(); } } }

输出结果： Thread-0正在进行读操作 Thread-0正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 … Thread-1正在进行读操作 Thread-1正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 … Thread-0读操作完毕 Thread-1正在进行读操作 Thread-1读操作完毕

通过以上可以2种不同的方式可以看出，读锁是同时进行的，而synchronized每次只能允许一个锁。

通过以上总结一下Lock与synchronized的区别。 1）Lock是一个接口，而synchronized是Java中的关键字，是代码级的，synchronized是内置的语言实现，是JVM级的； 2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁； 3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断； 4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。 5）Lock可以提高多个线程进行读操作的效率。 6）Lock可以实现公平锁，synchronized只能是非公平的。

注意：与synchronized对应的Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而并发包中的Lock（确切的说是同步器）拥有一个同步队列和多个等待队列。