java并发安全之锁

大家好，我是三叔，很高兴这期又和大家见面了，一个奋斗在互联网的打工人。

写一遍整理过的学习笔记把，分享一下java中锁的概念性的知识点。

什么是锁？

锁，字面意义就是一把锁（仿佛在说废话），锁是拿来干嘛的？当然是保护的，锁住某个物品或东西，锁内的东西都是安全的，只有有钥匙的人才能进去。
在java中，锁的概念并不是有钥匙才能进去，不过是差不多的意思，拥有对象的锁的资源，才拥有对对象的访问权。

java中的锁

乐观锁

是一种乐观思想，乐观锁是认为当前环境读多写少，并发写的概率比较低，读的时候是共享的，更新数据的时候，进行比较，判断当前值与期望值是否相同，如果相同就进行更新，更新的时候加锁，保证原子性。
java中的乐观锁：cas，比较并进行替换，比较当前线程的值，是否和主内存中的值相等，如果相同，则进行修改。

悲观锁

悲观锁有：synchronization同步锁、ReentrantLock可重入锁
悲观锁是一种悲观思想，认为当前环境的并发冲突比较高，随时都有并发的概率，数据是不安全的，所以读写都是独占的，其他线程消费数据只能进行阻塞，直到拿到当前对象的锁，才能对其进行读写操作。

自旋锁

线程切换，会进行内核和用户态的切换，给jvm并发带来很大的压力，自选会让当前线程挂起，等待释放锁，长时间挂起消耗资源，现在有自适应自旋锁，可以设置自旋的次数。
java实现的自旋锁可以使用CAS进行比较，操作失败进行自旋等待，设置自旋的次数。

可重入锁（递归锁）

java中的可重入锁：ReentrantLock、synchronization都可以实现可重入锁，也叫递归锁，对象可以重复获取锁对象，不会阻塞，获取一次，锁的次数加1，释放锁时，进行计数自减1，加了多少把锁，就要释放多少次锁，这样线程才会出来。
如果释放次数少于加锁次数，线程会一直锁住出不来，程序会卡死；
如果释放次数大于加锁次数，则会抛出异常：java.lang.IllegalMonitorStateException
可重入锁：有公平锁也有非公平锁；
所谓公平锁：就是当前线程执行完后会让后面等待的顺序进行获取锁对象；
非公平锁：在当前锁对象释放锁资源，随时可以被其他线程获取，线程唤醒是需要时间的，这个时间段随时都可能被其他对象。
ReentrantLock可以实现公平锁，默认是非公平锁，可以通过代码进行设置：
Lock lock = new ReentrantLock(true) - - - true就是公平锁。

看看synchronized和lock如何实现可重入锁？

synchronized异常会自动释放锁；Lock异常不会自动释放锁；

synchronized是非公平锁；LOCK可以实现公平锁

// synchronized实现的可重入锁   synchronized 遇到异常会自动释放锁
  // 可重入锁
    public static void main(String[] args) {
        Object obj = new Object();
        new Thread(() -> {
            //第一次加锁
            synchronized (obj) {
                System.out.println(Thread.currentThread().getName() + "第一层");
                //第二次加锁，此时obj对象处于锁定状态，但是当前线程仍然可以进入，避免死锁
                synchronized (obj) {
                    int a = 3 / 0;
                    System.out.println(Thread.currentThread().getName() + "第二层");
                }
            }

        }, "t1").start();
        new Thread(() -> {
            //第一次加锁
            synchronized (obj) {
                System.out.println(Thread.currentThread().getName() + "第一层");
                //第二次加锁，此时obj对象处于锁定状态，但是当前线程仍然可以进入，避免死锁
                synchronized (obj) {
                    System.out.println(Thread.currentThread().getName() + "第二层");
                }
            }
        },"t2").start();
    }

// Lock实现可重入锁   异常不会释放锁，所以需要手动释放锁资源
 public static void main(String[] args) {
        Lock lock = new ReentrantLock(false); // 非公平锁
        new Thread(() -> {
            //第一次加锁
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "第一层");
                //第二次加锁，此时lock处于锁定状态，但是当前线程仍然可以进入，避免死锁
                lock.lock();
                try {
                    int a = 3 / 0;
                    System.out.println(Thread.currentThread().getName() + "第二层");
                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
 
        }, "t1").start();
        new Thread(() -> {
            //第一次加锁
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "第一层");
                //第二次加锁，此时lock处于锁定状态，但是当前线程仍然可以进入，避免死锁
                lock.lock();
                try {
                    //int a=3/0;
                    System.out.println(Thread.currentThread().getName() + "第二层");
                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

读写锁 ReentrantReadWriteLock

java提供的读写锁，允许多个线程获取读锁，在没有写锁的情况下，是无阻塞的，

读锁：是独占资源，只允许一个线程进行访问

 public static void main(String[] args) {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();// 源码默认fail是false  非公平的
        // 创建读锁
        rwLock.readLock().lock();
        // 读锁解锁
        rwLock.readLock().unlock();

        // 创建写锁
        rwLock.writeLock().lock();
        // 写锁解锁
        rwLock.writeLock().unlock();
    }

写在最后

这期给大家主要介绍的是并发编程中，出现频率比较多的锁的一些实现以及机制，锁的机制不止于此，本文简单写了一些常见锁的使用，还有比如锁的优化，锁的粒度如何升级等，后期有时间，我会写一写同步锁的一些底层原理，帮助大家和自己更好的学习java。

Tips

欢迎交流沟通，互相学习，有错误的地方还望博友指出问题所在，万分感谢。以后会输出一些不同于其他博主的文章，主要都是一些学习笔记的随笔整理，以及自己阅读知识类书籍的笔记整理，后期希望自己能输出一些开发过程中遇到的”坑“给大家，同时也希望自己能坚持记录博客，勉励自己。最后希望有缘人能动手敲，不动手永远学不会新知识。