synchronized 是关键字,就和 if...else... 一样,是语法层面的实现。因此 synchronized 获取锁以及释放锁都是 Java 虚拟机(JVM)帮助用户完成的。
ReentrantLock 是类层面的实现,因此锁的获取以及锁的释放都需要用户自己去操作。
特别再次提醒,ReentrantLock 在 lock() 获取锁后,一定要手动 unlock() 释放锁,释放锁一般放在 finally 语句块中。
示例代码:
/** 创建可重入锁 */ private static final ReentrantLock lock = new ReentrantLock(); public void demoSync() { synchronized (lock) { // 业务代码 } } public void demoLock() { lock.lock(); try { // 业务代码 } finally { lock.unlock(); } }
synchronized 使用简单,简单意味着不灵活。而 ReentrantLock 的锁机制给用户的使用提供了极大的灵活性。
ReentrantLock 的灵活性在 Hashtable 和 ConcurrentHashMap 中体现得淋漓尽致。synchronized 一锁就锁整个 Hash 表,而 ConcurrentHashMap 则利用 ReentrantLock 实现了锁分离,锁的只是 segment(代码片段) 而不是整个 Hash 表。
部分 ConcurrentHashMap 的源码,仅作参考:
/** * Stripped-down version of helper class used in previous version, * declared for the sake of serialization compatibility */ static class Segment<K,V> extends ReentrantLock implements Serializable { private static final long serialVersionUID = 2249069246763182397L; final float loadFactor; Segment(float lf) { this.loadFactor = lf; } } /** * Saves the state of the {@code ConcurrentHashMap} instance to a * stream (i.e., serializes it). * @param s the stream * @throws java.io.IOException if an I/O error occurs * @serialData * the key (Object) and value (Object) * for each key-value mapping, followed by a null pair. * The key-value mappings are emitted in no particular order. */ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { // For serialization compatibility // Emulate segment calculation from previous version of this class int sshift = 0; int ssize = 1; while (ssize < DEFAULT_CONCURRENCY_LEVEL) { ++sshift; ssize <<= 1; } int segmentShift = 32 - sshift; int segmentMask = ssize - 1; @SuppressWarnings("unchecked") Segment<K,V>[] segments = (Segment<K,V>[]) new Segment<?,?>[DEFAULT_CONCURRENCY_LEVEL]; for (int i = 0; i < segments.length; ++i) segments[i] = new Segment<K,V>(LOAD_FACTOR); s.putFields().put("segments", segments); s.putFields().put("segmentShift", segmentShift); s.putFields().put("segmentMask", segmentMask); s.writeFields(); Node<K,V>[] t; if ((t = table) != null) { Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length); for (Node<K,V> p; (p = it.advance()) != null; ) { s.writeObject(p.key); s.writeObject(p.val); } } s.writeObject(null); s.writeObject(null); segments = null; // throw away }
synchronized 是不公平锁,而 ReentrantLock 可以指定锁是公平的还是非公平的,可通过 ReentrantLock(boolean fair) 构造方法的 fair 指定公平策略,如果此锁应该使用公平的排序策略,则 fair 参数为 true。
公平锁是指多个线程按照申请锁的顺序来获取锁,线程直接进入队列中排队,队列中的第一个线程才能获得锁。
非公平锁是多个线程加锁时直接尝试获取锁,能抢到锁到直接占有锁,抢不到才会到等待队列的队尾等待。
synchronized 实现等待/通知机制通知的线程是随机的,ReentrantLock 实现等待/通知机制可以有选择性地通知。
和 synchronized 相比,ReentrantLock 提供给用户多种方法用于获取锁的信息,例如:可以获取 Lock 是否被当前线程获得、Lock 被同一个线程调用了几次、Lock 是否被任意线程获取等等
如果只需要锁定简单的方法、简单的代码块,那么考虑使用synchronized,复杂的多线程处理场景下可以考虑使用ReentrantLock。