Java 并发锁机制

Java中的锁机制

1. 乐观锁与悲观锁

乐观锁：不加锁，通过版本号进行控制

悲观锁：加锁

2. 公平锁非公平锁

公平锁：排队一个一个来

ReentrantLock(false)

非公平锁：容许插队，性能更高，默认都是非公平锁

synchronized、ReentrantLock

3. 独享锁/共享锁：

独享锁：一次只能被一个线程所持有。
共享锁：该锁可被多个线程所持有。

4. 可重入锁

ReentrantLock 和 synchronized 都是可重入锁

5. 分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。

ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。
当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。
在统计size的时候，就需要获取所有的分段锁才能统计。
分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

6. 偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

• 偏向锁的适用场景

  始终只有一个线程在执行同步块，在它没有执行完释放锁之前，没有其它线程去执行同步块，在锁无竞争的情况下使用，一旦有了竞争就升级为轻量级锁，升级为轻量级锁的时候需要撤销偏向锁，撤销偏向锁的时候会导致stop the word操作；
  在有锁的竞争时，偏向锁会多做很多额外操作，尤其是撤销偏向所的时候会导致进入安全点，安全点会导致stw，导致性能下降，这种情况下应当禁用；

• 轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

• 重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

7. 读写锁

独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。

• 读-读 可共存
• 读-写 不可共存
• 写-写 不可共存

// 资源类
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void put(String key, Object value){
        lock.writeLock().lock();
        System.out.println("正在写入：" + key);
        try {
            TimeUnit.MILLISECONDS.sleep(300);
            map.put(key, value);
            System.out.println("写入完成！！！");
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
    public void get(String key){
        lock.readLock().lock();
        System.out.println("正在读取：" + key);
        try {
            TimeUnit.MILLISECONDS.sleep(100);
            Object o = map.get(key);
            System.out.println("读取完成，结果：" + o);
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }
    public void clear(){
        map.clear();
    }
}

/**
 * @author zhj
 */
public class ReadWriteLockDemo {
    /**
     * 读写锁  ---------读写分离，提高并发能力
     * 读-读可共存
     * 读-写不可共存
     * 写-写不可共存
     * @param args
     */
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.put(tempInt+"",tempInt+"");
            },"w" + i).start();
        }

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.get(tempInt+"");
            },"r" + i).start();
        }
        myCache.clear();
    }
}

8. 自旋锁

利用循环进行判断是否加锁，基于CAS（比较并交换）

public class SpinLockDemo {

    // 原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "\t come in O(n_n)O");

        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void myUnlock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(thread.getName() + "\t invoked myUnlock");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            try {
                spinLockDemo.myLock();
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e){
                e.printStackTrace();
            } finally {
                spinLockDemo.myUnlock();
            }
        },"T1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e){
            e.printStackTrace();
        }
        new Thread(()->{
            try {
                spinLockDemo.myLock();
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e){
                e.printStackTrace();
            } finally {
                spinLockDemo.myUnlock();
            }
        },"T2").start();
    }
}