JAVA锁机制

synchronized

可重入锁，看一段代码
public static void main(String[] args) {
        B1 b1  = new B1();
        B1 b2  = new B1();

        Thread t1 = new Thread(()->{b1.say("p1");});
        t1.start();
        Thread t2 = new Thread(()->{b1.say("p2");});
        t2.start();
    }

    public synchronized void say(String p1){
        synchronized (this){
            System.out.println(p1);
            try {
                TimeUnit.MINUTES.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

编译后的代码

经过jstack查看运行状态：

LockSupport

java还有3个锁是经过LockSupoort实现的。为何要说这个了，由于这个类支持线程的阻塞与释放。 ReentrantLock, ReentrantReadWriteLock,StampedLock。 其中ReentrantLock,ReentrantReadWriteLock支持公平与非公平锁。
公平：FIFO
非公平：随机

ReentrantLock

可重入锁，我们先本身实现一个这样的非公平锁。

1 须要一个状态，标记是否已有线程获取到锁了。0 未被锁定 1 被锁定
2 支持重入，须要知道这个锁被哪一个线程持有，后续该线程再次获取锁时，状态+1，表明该线程获取了几回锁
3 2个线程同时获取锁，能够通compareAndSet原子方法进行状态改变，当某个线程获取失败，能够返回失败，也能够阻塞，等待继续获取锁，还能够自旋继续获取锁。非公平锁挺适合用自旋的。
4 锁的释放，当某个线程释放锁时，因为同一个时刻有且只能有一个线程释放锁，能够将状态变动，可重入锁得进行减1释放。
5 Condition实现，主要有await,signal，signalAll方法。
6 await方法，首先须要释放锁，这个很简单，调用Lock的方法就能够。而后调用LockSupport的阻塞方法，将当前线程阻塞掉。因为须要支持signal，因此这里须要一个队列，来记录顺序，当signal的时候，取出第一个await进行唤醒。唤醒后，继续经过自旋获取锁，拿到锁后，就能够return掉了。
7 signal方法，唤醒第一个await的线程。
8 signalAll方法，唤醒全部的await线程。

可重入公平锁

1 稍微改动下，不用自旋的方法，咱们改为用LockSupport的阻塞方法。
2 2个线程同时获取锁，先判断是否能够重入，重入锁状态+1,而后返回。不然建立一个队列，若是不存在。而后状态将该线程加入队尾，再阻塞该线程。
3 彻底释放锁的时候，彻底释放是指锁状态为0，这个时侯，能够从队首拿出线程，消除阻塞，设置该线程获取锁，而后返回。

ReentrantReadWriteLock

可重入读写锁。读能够屡次，写只能一个线程获取。读写互斥。 公平与非公平，能够参照ReentrantLock。 这里的读锁能够理解为共享锁。

1 获取读锁时，先看是否有写锁。
2 获取写锁时，先看是否有读锁。
3 获取读锁，须要将每一个线程都存起来，并将每一个线程重入了几回记录起来。剩下的就好办了。

StampedLock

jdk8 提供的锁，只不过是对ReentrantReadWriteLock的优化。可是它不支持Condition。有一个优势时，它是乐观锁。 何为乐观锁：咱们能够看一段源码：

public long tryOptimisticRead() {
        long s;
        return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
    }

能够看到这里只是判断是否有写锁。 对于大部分都是读的场景，能够这样用。当你对这个数据使用完以后，须要校验是否有写锁。