理解 JVM：Java 内存模型（三）—— 锁

什么是线程安全？

线程安全是指当一个对象被多个线程访问操做时，最终都能获得正确的结果，那这个对象是线程安全的。Java 中能够经过同步块和加锁保障线程安全。

---

锁

锁是 Java 并发编程中最重要的同步机制，它可让等待在临界区的线程互斥执行。

关键字 synchronized

synchronized 也是一种锁，它经过字节码指令 monitorenter 和 monitorexist 隐式的来使用 lock 和 unlock 操做。synchronized 具备原子性和可见性。

synchronized 示例：

/**
 * @Project Name:test
 * @File Name:SynchronizedTest.java
 * @Package Name:com.pdh
 * @Date:2017年2月12日下午5:36:46
 */

package com.pdh.test.thread;

/**
 * synchronized 具备原子性和可见性
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class SynchronizedDemo {

	private int safeNum = 0;
	private int unsafeNum = 0;

	/**
	 * 使用 synchronized 同步实现复合运算,线程安全的
	 */
	private synchronized void safeIncrease() {
		safeNum++;
	}

	/**
	 * 普通复合运算，线程不安全的
	 */
	private void unsafeIncrease() {
		unsafeNum++;
	}

	public static void main(String[] args) {
		SynchronizedDemo demo = new SynchronizedDemo();
		for (int i = 0; i < 20000; i++) {
			new Thread(() -> {
				demo.unsafeIncrease();
				demo.safeIncrease();
			}).start();
		}

		while (Thread.activeCount() > 2) {
			Thread.yield();
		}

		System.out.println("unsafeNum: " + demo.unsafeNum);
		System.out.println("safeNum: " + demo.safeNum);
	}
}

在示例中，申明了两个方法，一个是使用了 synchronized 修饰的同步块方法 safeIncrease() 对共享变量 safeNum 的自增操做，因为该方法使用了 synchronized 同步块实现了线程对变量 safeNum 的互斥操做，是线程安全的，因此最终获取到了正确的结果 20000；而另外一个方法 unsafeIncrease() 为使用任何手段保护 全局变量 unsafeNum，是线程不安全的，因此最终获取到的结果大多数状况下是小于 20000 的。

重入锁（ReentrantLock）

从 JDK 5.0 开始，Java 并发包实现了高性能的支持重入的锁 ReentrantLock，属于一种排它锁。重入锁经过显示的请求获取和释放锁，为了不得到锁后，没有释放锁，而形成其它线程没法得到锁而形成死锁，通常建议将释放锁操做放在finally块里。

重入锁示例：

package com.pdh.test.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentrantLock 实现线程同步
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class ReentrantLockDemo implements Runnable {
	private int num = 0;
	private Lock lock = new ReentrantLock();

	/**
	 * 利用重入锁实现变量累加操做
	 */
	private void increase() {
		lock.lock();
		try {
			num++;
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}

	public static void main(String[] args) {
		ReentrantLockDemo demo = new ReentrantLockDemo();
		for (int i = 0; i < 2000; i++) {
			new Thread(() -> {
				demo.increase();
			}).start();
		}
		// 等待全部线程所有执行完
		while (Thread.activeCount() > 2) {
			Thread.yield();
		}
		System.out.println(demo.num);
	}
}

重入锁提供如下几个主要方法

• lock()：得到锁，若是锁已经被占用，则等待；
• lockInterruptibly()：获取锁，若获取成功当即返回；若获取不成功则阻塞等待。与lock方法不一样的是，在阻塞期间，若是当前线程被打断（interrupt）则该方法抛出InterruptedException。该方法能够有效避免死锁题。
• tryLock()：该方法尝试获取锁，若是成功，返回 true ，若失败返回 false。该方法不等待，当即返回。
• tryLock(long time, TimeUnit unit)：该方法尝试获取锁，若成功，则返回 true，若失败，则等待相应的时间，若是该时间内能得到锁，则返回 true，若是相应的时间内仍未获取到锁则返回 false，若是在等待期间当前线程被中断则抛出 InterruptedException；
• unlock()：释放锁；

synchronized 与 ReentrantLock 的区别

1. 全部使用 synchronized 的地方均可以使用 ReentrantLock ；
2. synchronized 是经过字节码指令 monitorenter 和 monitorexist 实现隐式加锁和解锁，而 ReentrantLock 是经过 lock 和 unlock 操做实现显示加锁和解锁；
3. ReentrantLock 能够实现公平和非公平两种锁，而 synchronized 只能实现非公平锁；
4. ReentrantLock 能够中断对锁的等待来避免 synchronized 可能带来的死锁问题；

Condition 条件锁

Condition 的用法与 wait() 和 notify() 做用相似，wait() 和 notify() 是和 synchronized 关键字搭配使用，而 Condition 是与重入锁搭配使用。利用 Condition 对象，就可让线程在合适的时间等待，或者在某个特定的时刻获得通知，继续执行。

Condition 提供如下几个方法

• await()：该方法会使当前线程等待，同时释放当前锁，当其它线程中使用 signal() 或者 singnalAll() 方法时，线程会从新得到锁并继续执行。或者当前线程被中断时，也能跳出等待。
• awaitUninterruotibly()：该方法使用和 await() 基本相同，可是它不会再等待的过程当中响应中断。
• singal()：该方法用于唤醒一个在等待中的线程，而 singalAll() 方法会唤醒全部在等待的方法。

Condition 示例：

package com.pdh.test.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Condition 示例
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class ConditionDemo {

	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		new Thread(() -> {
			lock.lock();
			System.out.println("thread 1 is waiting");
			try {
				condition.await();
				System.out.println("thread 1 is wake up");
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
			}
		}).start();

		new Thread(() -> {
			lock.lock();
			try {
				System.out.println("thread 2 is running");
				Thread.sleep(3000);
				condition.signal();
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				lock.unlock();
			}
		}).start();
	}
}

信号量（Semaphore）

信号量为多线程协做提供了更为强大的控制方法，广义上说，信号量是对锁的扩展。不管是内部锁 synchronized 仍是重入锁 ReentrantLock，一次都只容许一个线程访问一个资源，而信号量却能够指定多个线程，同时访问某一个资源。

信号量提供了如下方法

• acquire()：该方法尝试得到一个许可。若没法得到，则线程会等待，直到有线程释放一个许可或者当前线程被中断。
• acquire(int permits)： 申请 permits（必须为非负数）个许可，若获取成功，则该方法返回而且当前可用许可数减permits；若当前可用许可数少于 permits 指定的个数，则继续等待可用许可数大于等于 permits；若等待过程当中当前线程被中断，则抛出 InterruptedException。
• acquireUninterruptibly() ：该方法和 acquire() 相似，但不响应中断。
• tryAcquire()：尝试得到一个许可 ，若是成功则返回 true，若是失败则返回 false，它不会进行等待，当即返回。
• release()：用于在线程访问资源结束后，释放一个许可，以使其它等待许可的线程能够进行资源访问。

Semaphore 示例：

package com.pdh.test.thread;

import java.util.concurrent.Semaphore;

/**
 * 信号量示例
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class SemaphoreDemo {
	private static final Semaphore semaphoreToken = new Semaphore(5);

	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			new Thread(() -> {
				// 获取令牌
				try {
					semaphoreToken.acquire();
					Thread.sleep(2000);
					System.out.println(Thread.currentThread().getId() + " finished");
					// 归还令牌
					semaphoreToken.release();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}).start();
		}
	}
}

读写锁（ReadWriteLock）

读写锁适用于多线程编程中读多写少的场景中，对于原子性而言，更可能是关注写操做，读和读操做之间并不须要互斥操做，只须要保证读和写或者写和写之间是互斥操做便可。因此若是在某个场景下读操做次数远远大于写操做次数，则可使用读写锁来提升效率。

读写锁示例

package com.pdh.test.thread;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁示例
 *
 * @author pengdh
 * @date 2017/11/13
 */
public class ReadWriteLockDemo {

	public static void main(String[] args) {
		ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
		new Thread(() -> {
			readWriteLock.readLock().lock();
			try {
				System.out.println("the first read lock begin");
				Thread.sleep(1000);
				System.out.println("the first read lock end");
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				readWriteLock.readLock().unlock();
			}
		}).start();

		new Thread(() -> {
			readWriteLock.readLock().lock();
			try {
				System.out.println("the second read lock begin");
				Thread.sleep(1000);
				System.out.println("the second read lock end");
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				readWriteLock.readLock().unlock();
			}
		}).start();

		new Thread(() -> {
			readWriteLock.writeLock().lock();
			try {
				System.out.println("the write lock begin");
				Thread.sleep(1000);
				System.out.println("the write read lock end");
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				readWriteLock.writeLock().unlock();
			}
		}).start();
	}
}

---

参考文献

• <span style="color:red;font-size:14px;font-family:Microsoft YaHei;">深刻理解 Java 虚拟机</span>

欢迎扫一扫关注 程序猿pdh 公众号！