浅谈Java中的锁：Synchronized、重入锁、读写锁

Java开发必需要掌握的知识点就包括如何使用锁在多线程的环境下控制对资源的访问限制

◆
Synchronized
◆

首先咱们来看一段简单的代码：

12345678910111213141516171819复制代码

public class NotSyncDemo { public static int i=0; static class ThreadDemo extends Thread { @Override public void run() { for (int j=0;j<10000;j++){ i++; } } } public static void main(String[] args) throws InterruptedException { ThreadDemo t1=new ThreadDemo(); ThreadDemo t2=new ThreadDemo(); t1.start();t2.start(); t1.join(); t2.join(); System.out.println(i); }}复制代码

上方的代码使用了2个线程同时对静态变量i进行++操做，理想中的结果最后输出的i的值应该是20000才对，可是若是你执行这段代码的时候你会发现最后的结果始终是一个比20000小的数。这个就是因为JMM规定线程操做变量的时候只能先从主内存读取到工做内存，操做完毕后在写到主内存。而当多个线程并发操做一个变量时极可能就会有一个线程读取到另一个线程尚未写到主内存的值从而引发上方的现象。更多关于JMM的知识请参考此文章：Java多线程内存模型

想要避免这种多线程并发操做引发的数据异常问题一个简单的解决方案就是加锁。JDK提供的synchronize就是一个很好的选择。
synchronize的做用就是实现线程间的同步，使用它加锁的代码同一时刻只能有一个线程访问，既然是单线程访问那么就确定不存在并发操做了。
synchronize能够有多种用法，下面给出各个用法的示例代码。

◆
Synchronized的三种使用方式
◆

给指定对象加锁，进入代码前须要得到对象的锁

1234567891011121314151617181920212223复制代码

public class SyncObjDemo { public static Object obj = new Object(); public static int i = 0; static class ThreadDemo extends Thread { @Override public void run() { for (int j = 0; j < 10000; j++) { synchronized (obj) { i++; } } } } public static void main(String[] args) throws InterruptedException { ThreadDemo t1 = new ThreadDemo(); ThreadDemo t2 = new ThreadDemo(); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); }}复制代码

给方法加锁，至关于给当前实例加锁，进入代码前须要得到当前实例的锁

123456789101112131415161718192021222324复制代码

public class SyncMethodDemo { public static int i = 0; static class ThreadDemo extends Thread { @Override public void run() { for (int j = 0; j < 10000; j++) { add(); } } public synchronized void add(){ i++; } } public static void main(String[] args) throws InterruptedException { ThreadDemo threadDemo=new ThreadDemo(); Thread t1 = new Thread(threadDemo); Thread t2 = new Thread(threadDemo); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); }}复制代码

给静态方法加锁，至关于给当前类加锁，进入代码前须要得到当前类的锁。这种方式请慎用，都锁住整个类了，那效率能高哪去

123复制代码

public static synchronized void add(){ i++; }复制代码

◆
重入锁
◆

在JDK6尚未优化synchronize以前还有一个锁比它表现的更为亮眼，这个锁就是重入锁。
咱们来看一下一个简单的使用重入锁的案例：

12345678910111213141516171819202122232425262728复制代码

public class ReentrantLockDemo { public static ReentrantLock lock = new ReentrantLock(); public static int i = 0; static class ThreadDemo extends Thread { @Override public void run() { for (int j = 0; j < 10000; j++) { lock.lock(); try { i++; }finally { lock.unlock(); } } } } public static void main(String[] args) throws InterruptedException { ThreadDemo t1 = new ThreadDemo(); ThreadDemo t2 = new ThreadDemo(); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); }}复制代码

上方代码使用重入锁一样实现了synchronize的功能。而且呢，咱们能够看到使用冲入锁是显示的指定何时加锁何时释放的，这样对于一些流程控制就会更加的有优点。

再来看这个锁为何叫作重入锁呢，这是由于这种锁是能够反复进入的，好比说以下操做是容许的。

12345678复制代码

lock.lock();lock.lock();try { i++;}finally { lock.unlock(); lock.unlock();}复制代码

不过须要注意的是若是屡次加锁的话一样也要记得屡次释放，不然资源是不能被其余线程使用的。

在以前的文章：多线程基本概念 中有提到过由于线程优先级而致使的饥饿问题，重入锁提供了一种公平锁的功能，能够忽略线程的优先级，让全部线程公平竞争。使用公平锁的方式只须要在重入锁的构造方法传入一个true就能够了。

1复制代码

public static ReentrantLock lock = new ReentrantLock(true);复制代码

重入锁还提供了一些高级功能，例如中断。
对于synchronize来讲，若是一个线程获取资源的时候要么阻塞要么就是获取到资源，这样的状况是没法解决死锁问题的。而重入锁则能够响应中断，经过放弃资源而解决死锁问题。
使用中断的时候只须要把原先的lock.lock()改为lock.lockInterruptibly()就OK了。
来看代码示例：

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253复制代码

public class ReentrantLockInterruptDemo { public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); static class ThreadDemo extends Thread { int i = 0; public ThreadDemo(int i) { this.i = i; } @Override public void run() { try { if (i == 1) { lock1.lockInterruptibly(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } lock2.lockInterruptibly(); } else { lock2.lockInterruptibly(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } lock1.lockInterruptibly(); } System.out.println(Thread.currentThread().getName() + "完成任务"); } catch (InterruptedException e) { e.printStackTrace(); } finally { if (lock1.isHeldByCurrentThread()) { lock1.unlock(); } if (lock2.isHeldByCurrentThread()) { lock2.unlock(); } System.out.println(Thread.currentThread().getName() + "退出"); } } } public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new ThreadDemo(1),"t1"); Thread t2 = new Thread(new ThreadDemo(2),"t2"); t1.start(); t2.start(); Thread.sleep(1500); t1.interrupt(); }}复制代码

查看上方代码咱们能够看到，线程t1启动后先占有lock1，而后会在睡眠1秒以后试图占有lock2，而t2则先占有lock2，而后试图占有lock1。这个过程则势必会发生死锁。而若是再这个时候咱们给t1一个中断的信号t1就会响应中断从而放弃资源，继而解决死锁问题。

除了提供中断解决死锁之外，重入锁还提供了限时等待功能来解决这个问题。
限时等待的使用方式是使用lock.tryLock(2,TimeUnit.SECONDS)
这个方法有两个参数，前面是等待时长，后面是等待时长的计时单位，若是在等待时长范围内获取到了锁就会返回true。

请看代码示例：

1234567891011121314151617181920212223242526272829303132复制代码

public class ReentrantLockTimeDemo { public static ReentrantLock lock = new ReentrantLock(); static class ThreadDemo extends Thread { @Override public void run() { try { if (lock.tryLock(2, TimeUnit.SECONDS)) { try { System.out.println(Thread.currentThread().getName() + "获取锁成功"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } else { System.out.println(Thread.currentThread().getName() + "获取锁失败"); } } catch (InterruptedException e) { e.printStackTrace(); } finally { if (lock.isHeldByCurrentThread()) { lock.unlock(); } } } } public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new ThreadDemo(), "t1"); Thread t2 = new Thread(new ThreadDemo(), "t2"); t1.start(); t2.start(); }}复制代码

一样的tryLock也能够不带参数，不带参数的时候就是表示当即获取，获取不成功就直接返回false

咱们知道synchronize配合wait和notify能够实现等待通知的功能，重入锁一样也提供了这种功能的实现。那就是condition。使用lock.newCondition()就能够得到一个Condition对象。

下面请看使用Condition的代码示例：

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647复制代码

public class ReentrantLockWaitNotifyThread { public static ReentrantLock lock = new ReentrantLock(); public static Condition condition = lock.newCondition(); static class WaitThreadDemo extends Thread { @Override public void run() { try { System.out.println("WaitThread wait,time=" + System.currentTimeMillis()); lock.lock(); condition.await(); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); System.out.println("WaitThread end,time=" + System.currentTimeMillis()); } } } static class NotifyThreadDemo extends Thread { @Override public void run() { lock.lock(); System.out.println("NotifyThread notify,time=" + System.currentTimeMillis()); condition.signal(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); System.out.println("NotifyThread end,time=" + System.currentTimeMillis()); } } } public static void main(String[] args) { WaitThreadDemo waitThreadDemo = new WaitThreadDemo(); NotifyThreadDemo notifyThreadDemo = new NotifyThreadDemo(); waitThreadDemo.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } notifyThreadDemo.start(); }}复制代码

◆
读写锁
◆

经过上方的内容咱们知道了为了解决线程安全问题，JDK提供了至关多的锁来帮助咱们。可是若是多线程并发读的状况下是不会出现线程安全问题的，那么有没有一种锁能够在读的时候不控制，读写冲突的时候才会控制呢。答案是有的，JDK提供了读写分离锁来实现读写分离的功能。

这里给出使用读写锁的一个代码示例

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152复制代码

public class ReadWriteLockDemo { public static ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); public static Lock readLock = readWriteLock.readLock(); public static Lock writeLock = readWriteLock.writeLock(); public static void read(Lock lock) { lock.lock(); try { System.out.println("readTime：" + System.currentTimeMillis()); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } public static void write(Lock lock) { lock.lock(); try { System.err.println("writeTime：" + System.currentTimeMillis()); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } static class ReadThread extends Thread { @Override public void run() { read(readLock); } } static class WriteThread extends Thread { @Override public void run() { write(writeLock); } } public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 10; i++) { new ReadThread().start(); } new WriteThread().start(); new WriteThread().start(); new WriteThread().start(); }}复制代码

上方代码模拟了10个线程并发读，3个线程并发写的情况，若是咱们使用synchronize或者重入锁的时候我想上方最后的耗时应该是26秒多。可是若是你执行 一下上方的代码你就会发现仅仅只花费了6秒多。这就是读写锁的魅力。

本文全部源码github.com/shiyujun/sy…