java锁

java锁可以分为:重入锁、读写锁，悲观锁、乐观锁、分布式锁

重入锁

重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。
在JAVA环境下ReentrantLock(轻量级) 和synchronized（重量级）都是 可重入锁

synchronized与Lock的区别

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；

5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）

6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

读写锁

public class RWLock {
    //读写锁
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //读锁
    private static ReadLock readLock = readWriteLock.readLock();
    //写锁
    private static WriteLock writeLock = readWriteLock.writeLock();
    private static Map<String,String> dataMap = new HashMap<String, String>();
 
    //读数据
    public static String get(String key){
        try {
            //上读锁
            readLock.lock();
            Thread.sleep(500);
            return dataMap.get(key);
        }catch (Exception e){
 
        }finally {
            readLock.unlock();
        }
        return null;
    }
    //写数据
    public static void put(String key,String value){
        try {
            //上写锁
            writeLock.lock();
            dataMap.put(key, value);
 
        }catch (Exception e){
 
        }finally {
            writeLock.unlock();
        }
    }
 
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    RWLock.put(i + "", "i:" + i);
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    System.out.println(RWLock.get(i + ""));
                }
            }
        }).start();
    }
}

悲观锁、乐观锁
乐观锁

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

version方式
在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

核心SQL语句

update table set x=x+1, version=version+1 where id=#{id} and version=#{version};   

CAS操作方式
即compare and swap。jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁

它包含三个参数CAS(V,E,N): V表示要更新的变量，即主内存的值，E表示预期值，即本地内存的值，N表示新值，即操作后的值。仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS返回当前V的真实值。

（1）CAS操作是抱着乐观的态度进行的，它总是认为自己可以成功完成操作。当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。基于这样的原理，CAS操作即使没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。

（2）简单地说，如果主内存的值与本地内存值一致，说明没有被修改过，则将操作后的值刷新到主内存；如果不一致，则说明该值已经被修改过，需要重新将主内存的值刷新到本地内存，在进行循环比较。

CAS的优势：

①在高并发的情况下，它比有锁的程序拥有更好的性能

②它天生就是死锁免疫

CAS的劣势：

ABA问题

如果变量初次从主内存读取的值为A，后被赋值为B，而后又被赋值为A，那么刷新到主内存时，CAS会认为它没有被修改过。

针对这种情况，java并发包中提供了一个带有标记的原子引用类AtomicStampedReference，它可以通过控制变量值的版本来保证CAS的正确性。

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

分布式锁
如果想在不同的jvm中保证数据同步，使用分布式锁技术。

有数据库实现、缓存实现、Zookeeper分布式锁。