（六）并发编程之Java中的锁

Dear 丶 2022-01-26 02:17 310阅读 0赞

# 公平锁和非公平锁 #

*  公平锁  
    是指多个线程按照申请锁的顺序来获取锁类似排队打饭 先来后到
 *  非公平锁  
    是指在多线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象

**两者的区别：**  
公平锁/非公平锁  
并发包**ReentrantLock**的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁 默认是非公平锁  
![在这里插入图片描述][20190527212953201.png]  
**注：**

*  Java ReentrantLock而言,  
    通过构造哈数指定该锁是否是公平锁 默认是非公平锁 非公平锁的优点在于吞吐量必公平锁大。
 *  对于synchronized而言 也是一种非公平锁。

# 可重入锁(又名递归锁) #

![在这里插入图片描述][20190527213212133.png]  
在JAVA环境下 **ReentrantLock** 和**synchronized** 都是 可重入锁，可重入锁最大的作用就是避免死锁。

# 自旋锁 #

![在这里插入图片描述][20190527213610402.png]

# 独占锁(写)/共享锁(读)/互斥锁 #

![在这里插入图片描述][20190527213657979.png]

# 读写锁 #

相比Java中的锁(Locks in Java)里Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，**两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写**（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。Java5在java.util.concurrent包中已经包含了读写锁。尽管如此，我们还是应该了解其实现背后的原理。  
下面是读写锁使用的例子：

package com.bestqiang.thread.Lock;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /** * 资源类 */
    class MyCaChe { 
        /** * 保证可见性 */
        private volatile Map<String, Object> map = new HashMap<>();
        private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    
        /** * 写 * * @param key * @param value */
        public void put(String key, Object value) { 
            reentrantReadWriteLock.writeLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);
                //模拟网络延时
                try { 
                    TimeUnit.MICROSECONDS.sleep(300);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                map.put(key, value);
                System.out.println(Thread.currentThread().getName() + "\t正在完成");
            } finally { 
                reentrantReadWriteLock.writeLock().unlock();
            }
        }
    
        /** * 读 * * @param key */
        public void get(String key) { 
            reentrantReadWriteLock.readLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "\t正在读取");
                //模拟网络延时
                try { 
                    TimeUnit.MICROSECONDS.sleep(300);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                Object result = map.get(key);
                System.out.println(Thread.currentThread().getName() + "\t正在完成" + result);
            } finally { 
                reentrantReadWriteLock.readLock().unlock();
            }
        }
    
        public void clearCaChe() { 
            map.clear();
        }
    
    }
    
    /** * Description: * 多个线程同时操作 一个资源类没有任何问题 所以为了满足并发量 * 读取共享资源应该可以同时进行 * 但是 * 如果有一个线程想去写共享资源来 就不应该有其他线程可以对资源进行读或写 * <p> * 小总结: * 读 读能共存 * 读 写不能共存 * 写 写不能共存 * 写操作 原子+独占 整个过程必须是一个完成的统一整体 中间不允许被分割 被打断 **/
    public class ReadWriteLockDemo { 
        public static void main(String[] args) { 
            MyCaChe myCaChe = new MyCaChe();
            for (int i = 1; i <= 5; i++) { 
                final int temp = i;
                new Thread(() -> { 
                    myCaChe.put(temp + "", temp);
                }, String.valueOf(i)).start();
            }
            for (int i = 1; i <= 5; i++) { 
                int finalI = i;
                new Thread(() -> { 
                    myCaChe.get(finalI + "");
                }, String.valueOf(i)).start();
            }
        }
    }

# 悲观锁、乐观锁 #

*  乐观锁：  
    总是认为不会产生并发问题，每次去取数据的时候总认为不会有其他线程对数据进行修改，因此不会上锁，但是在更新时会判断其他线程在这之前有没有对数据进行修改，一般会使用版本号机制或CAS操作实现。

1.  version方式：一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。  
    核心SQL语句  
    update table set x=x+1, version=version+1 where id=\#\{id\} and version=\#\{version\};
2.  CAS操作方式：即compare and swap 或者 compare and set，涉及到三个操作数，数据所在的内存值，预期值，新值。当需要更新时，判断当前内存值与之前取到的值是否相等，若相等，则用新值更新，若失败则重试，一般情况下是一个自旋操作，即不断的重试。

*  悲观锁  
    总是假设最坏的情况，每次取数据时都认为其他线程会修改，所以都会加锁（读锁、写锁、行锁等），当其他线程想要访问数据时，都需要阻塞挂起。可以依靠数据库实现，如行锁、读锁和写锁等，都是在操作之前加锁，在Java中，synchronized的思想也是悲观锁。

# 分布式锁 #

如果想在不同的jvm中保证数据同步，使用分布式锁技术。  
有数据库实现、缓存实现、Zookeeper分布式锁

[20190527212953201.png]: /images/20220126/e29e6b4f205a4b49b1cfed4a7a95be14.png
[20190527213212133.png]: /images/20220126/56c4e7381f4849e7b3cc4a0adab893ea.png
[20190527213610402.png]: /images/20220126/721e19c64eb74fddb4b35bdd9311c468.png
[20190527213657979.png]: /images/20220126/b845c47677bf432e8d1bc30b27c00483.png