java中的各种锁

悲观锁:悲观锁悲观的认为每一次操作都会造成更新丢失问题，在每次查询时加上排他锁。

每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

Select * from xxx for update;  (这个for update就是在加锁，只能有一个连接操作该数据，其他的全部阻塞)

乐观锁:总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

读写锁

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

package com.zl.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author zhanglei
 * @description : java中的读写锁
 * @date 2021/4/8$ 15:32$
 * @return $
 */
public class ReadWriteLockDemo {

    public static void main(String[] args) {
        Cache cache = new Cache();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<11;i++){
                    cache.put(i+"",i+"");
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<11;i++){
                    cache.get(i+"");
                }
            }
        }).start();


    }


}

class Cache{

    private volatile Map<String,Object> map = new HashMap();

    ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    Lock readLock = reentrantReadWriteLock.readLock();
    Lock writeLock = reentrantReadWriteLock.writeLock();

    /**
     * 写操作
     */
    public void put(String key,Object value){
        writeLock.lock();
        try{
            System.out.println("开始写数据，key:"+key+"，数据:"+value);
            Thread.sleep(100);
            map.put(key, value);
            System.out.println("写数据结束，key:"+key+"，数据:"+value);
        }catch (Exception e){

        }finally {
            writeLock.unlock();
        }
    }

    /**
     * 读操作
     */
    public Object get(String key){
        readLock.lock();
        try{
            System.out.println("开始读数据，key:"+key);
            Thread.sleep(100);
            Object o = map.get(key);

            System.out.println("读数据结束，key:"+key+"，返回结果:"+o);
            return o;
        }catch (Exception e){

        }finally {
            readLock.unlock();
        }
        return null;
    }
}

结果：开始写数据，key:1，数据:1
写数据结束，key:1，数据:1
开始写数据，key:2，数据:2
写数据结束，key:2，数据:2
开始写数据，key:3，数据:3
写数据结束，key:3，数据:3
开始写数据，key:4，数据:4
写数据结束，key:4，数据:4
开始写数据，key:5，数据:5
写数据结束，key:5，数据:5
开始写数据，key:6，数据:6
写数据结束，key:6，数据:6
开始写数据，key:7，数据:7
写数据结束，key:7，数据:7
开始写数据，key:8，数据:8
写数据结束，key:8，数据:8
开始写数据，key:9，数据:9
写数据结束，key:9，数据:9
开始写数据，key:10，数据:10
写数据结束，key:10，数据:10
开始读数据，key:1
读数据结束，key:1，返回结果:1
开始读数据，key:2
读数据结束，key:2，返回结果:2
开始读数据，key:3
读数据结束，key:3，返回结果:3
开始读数据，key:4
读数据结束，key:4，返回结果:4
开始读数据，key:5
读数据结束，key:5，返回结果:5
开始读数据，key:6
读数据结束，key:6，返回结果:6
开始读数据，key:7
读数据结束，key:7，返回结果:7
开始读数据，key:8
读数据结束，key:8，返回结果:8
开始读数据，key:9
读数据结束，key:9，返回结果:9
开始读数据，key:10
读数据结束，key:10，返回结果:10