Java锁

一、公平锁和非公平锁

• 公平锁：多个线程按照申请锁的顺序来获取锁。好比生产线，每个商品依次按顺序进行加工。
• 非公平锁：多个线程获取锁的顺序并不是按照申请的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能造成优先级反转和饥饿现象（后面排队的锁由于长期被更后面的锁加塞而导致一直获取不到锁，就是饥饿现象）

   两者区别：

• 公平锁，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，若为空，或者当前线程是等待队列的第一个，就占有锁，否则就加入到等待队列中，以后会按照FIFO的规则从队列中取到自己
• 非公平锁，比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再用类似公平锁的方式。非公平锁优点是吞吐量比较大。

       也就是说：公平锁讲究的是先来后到，而非公平锁讲究的是弱肉强食。

   ReentrantLock：根据构造函数的参数指定是公平锁还是非公平锁，无参构造默认是非公平锁。

    /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

  Synchronized 也是一种非公平锁。

二、可重入锁（递归锁）

       指的是同一线程外层函数获得锁之后，内层递归函数仍然能获得该锁的代码。即，线程可以获得任何一个它已经拥有的锁 所同步着的代码块。

ReentrantLock和Synchronized 就是可重入锁。可重入锁的最大作用就是可以避免死锁。

三、自旋锁（spinlock）

   自旋锁：指的是尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

   就像之前文章中讲的CAS。

//unsafe.getAndAddInt
public final int getAndAddInt(Object var1,long var2,int var4){
    int var5;
    do{
        var5 = this.getIntVolatile(var1,var2);
    } while(!this.compareAndSwapInt(var1,var2,var5,var5 + var4));
        return var5;
}

四、独占锁（写锁）/共享锁（读锁）/互斥锁

• 独占锁：一次只能被一个线程所持有。例如：ReentrantLock 和 Synchronized 。
• 共享锁：可以被多个线程共同持有。例如：ReentrantReadWriteLock 的读锁是共享锁，写锁是独占锁。读锁的共享锁可保证并发读很高效，读写，写读，写写的过程是互斥的。

    下面举一个对缓存读写操作的栗子

class MyCache {
    private Map<String, String> map = new HashMap<>();

    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "\t 正在读取...");
        String result = map.get(key);
        try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(Thread.currentThread().getName() + "读取完成：" + result);
    }

    public void set(String key, String value) {
        System.out.println(Thread.currentThread().getName()+"\t 正在写入..."+ key);
        try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"\t 写入完成！");
    }
}

public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {
        final MyCache cache = new MyCache();

        for (int i = 1; i <= 5; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    cache.set(finalI +"", finalI +"");
                }
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    cache.get(finalI +"");
                }
            },String.valueOf(i)).start();
        }
    }
}

- 打印结果- -  - --  - - - -- - 
1	 正在写入...1
2	 正在写入...2
5	 正在写入...5
4	 正在写入...4
3	 正在写入...3
1	 正在读取...
2	 正在读取...
3	 正在读取...
4	 正在读取...
5	 正在读取...
1	 写入完成！
2	 写入完成！
5	 写入完成！
3	 读取完成：null
1	 读取完成：null
2	 读取完成：2
4	 读取完成：null
5	 读取完成：5
3	 写入完成！
4	 写入完成！

        以上代码可见在没有任何措施的情况下，打印结果不堪入目，还没写完，就开始读，也就是在写的过程中，被读操作插队 了，所以导致了读取数据为null。

下面加入读写锁

class MyCache {
    private Map<String, String> map = new HashMap<>();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void  get(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取...");
            Thread.sleep(1000);
            String result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void set(String key, String value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t 正在写入..."+ key);
            Thread.sleep(1000);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"\t 写入完成！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
}

public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {
        final MyCache cache = new MyCache();

        for (int i = 1; i <= 5; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    cache.set(finalI +"", finalI +"");
                }
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    cache.get(finalI +"");
                }
            },String.valueOf(i)).start();
        }
    }
}

---打印结果--------
1	 正在写入...1
1	 写入完成！
3	 正在写入...3
3	 写入完成！
2	 正在写入...2
2	 写入完成！
4	 正在写入...4
4	 写入完成！
5	 正在写入...5
5	 写入完成！
1	 正在读取...
2	 正在读取...
3	 正在读取...
4	 正在读取...
5	 正在读取...
1	 读取完成：1
3	 读取完成：3
5	 读取完成：5
2	 读取完成：2
4	 读取完成：4

        加入ReentrantReadWriteLock，在写入时使用其写锁：WriteLock，在读取时使用读锁：ReadLock，从打印结果来看，写入操作没有被其他操作加塞，是一气呵成的，具有原子性。这样读写分离既保证了数据的一致性，又提升了数据并发性。

      另外要注意：ReentrantReadWriteLock 和 ReentrantLock 不是继承关系，但都是基于 AbstractQueuedSynchronizer 来实现。

小结：虽然说了这么多种锁，但实际实现好多都是重复的，比如：

• ReentrantLock 既是公平和非公平锁，又是可重入锁，还是独占锁
• Synchronized 既是非公平锁，又是可重入锁，还是独占锁