Java深入学习（5）：锁

可重入锁：

简单来说，支持重复加锁，有可重用性

特征：锁可以传递，方法递归传递

目的：避免了死锁现象

代码：

public class Test implements Runnable {

    @Override
    public void run() {
        method1();
    }

    public synchronized void method1() {
        System.out.println("method1");
        method2();
    }

    public synchronized void method2() {
        System.out.println("method2");
    }

    public static void main(String[] args) {
        new Thread(new Test()).start();
    }

}

打印：

method1
method2

分析：如果锁不能重用，那么这里将会出现死锁问题

使用ReentrantLock锁：

public class TestLock implements Runnable {
    //重入锁
    private Lock reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        method1();
    }

    public void method1() {
        try {
            reentrantLock.lock();
            System.out.println("method1");
            method2();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public void method2() {
        try {
            reentrantLock.lock();
            System.out.println("method2");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public static void main(String[] args) {
        new Thread(new TestLock()).start();
    }

}

读写锁：

高并发的时候，写操作的同时应当不允许读操作

（多线程中：读-读共存；读-写、写-写都不可以共存）

代码：制造读写操作的线程安全问题

public class TestWriteLock {

    Map<String, String> cache = new HashMap<>();

    //写入元素
    public void put(String key, String value) {
        try {
            System.out.println("开始写入key : " + key + " value : " + value);
            Thread.sleep(50);
            cache.put(key, value);
            System.out.println("完成写入key : " + key + " value : " + value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //读取元素
    public String get(String key) {
        System.out.println("开始读取key : " + key);
        String value = cache.get(key);
        System.out.println("读取成功key : " + key + " value : " + value);
        return value;
    }

    public static void main(String[] args) {
        TestWriteLock test = new TestWriteLock();
        Thread readThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.put("i", i + "");
                }
            }
        });

        Thread writeThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.get("i");
                }
            }
        });

        readThread.start();
        writeThread.start();
    }
}

观察打印：发现不合理

开始写入key : i value : 0
开始读取key : i
读取成功key : i value : null
.................................

分析：在没有写入完成的时候，就开始了读取，得到的结果为空

解决：

1.使用synchronized，虽然可以解决，但是效率低下，写操作同时不能读，产生阻塞

2.使用读写锁

public class TestWriteLock {

    Map<String, String> cache = new HashMap<>();

    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
    ReentrantReadWriteLock.ReadLock readLock = lock.readLock();

    //写入元素
    public void put(String key, String value) {
        try {
            writeLock.lock();
            System.out.println("开始写入key : " + key + " value : " + value);
            Thread.sleep(50);
            cache.put(key, value);
            System.out.println("完成写入key : " + key + " value : " + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }

    //读取元素
    public String get(String key) {
        String value = "";
        try {
            readLock.lock();
            System.out.println("开始读取key : " + key);
            value = cache.get(key);
            System.out.println("读取成功key : " + key + " value : " + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
        return value;
    }

    public static void main(String[] args) {
        TestWriteLock test = new TestWriteLock();
        Thread readThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.put("i", i + "");
                }
            }
        });

        Thread writeThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.get("i");
                }
            }
        });
        readThread.start();
        writeThread.start();
    }
}

观察打印：完美解决

乐观锁：

简单来讲，乐观锁就是没有锁，无阻塞无等待

一条SQL语句做示范：

UPDATE TABLE SET X=X+1,VERSION=VERSION+1 WHERE ID=#{id} AND VERSION=#{version}

 在高并发地情况下，假设初始version是1，请求1到来，根据id和version能查到，所以允许更新

 请求2同时做操作，但是根据id和version已经查不到了（被请求1修改了），所以不允许更新

悲观锁：

简单来讲，重量级锁， 会阻塞，会进行等待

可以理解为上锁之后只允许一个线程来操作，也就是Java中的synchronized

原子类：

一段模拟线程安全问题的代码：

public class ThreadTest implements Runnable {

    private static int count = 1;

    @Override
    public void run() {
        while (true) {
            Integer count = getCount();
            if (count >= 100) {
                break;
            }
            System.out.println(count);
        }
    }

    public synchronized Integer getCount() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return count++;
    }

    public static void main(String[] args) {
        ThreadTest t = new ThreadTest();
        new Thread(t).start();
        new Thread(t).start();
    }

}

观察打印后发现果然出现了线程安全问题

一种修改方式：效率较低

    public synchronized Integer getCount() {

使用原子类：乐观锁，底层没有加锁，使用CAS无锁技术

public class ThreadTest implements Runnable {

    // 线程安全
    private AtomicInteger atomicInteger = new AtomicInteger();

    @Override
    public void run() {
        while (true) {
            Integer count = getCount();
            if (count >= 100) {
                break;
            }
            System.out.println(count);
        }
    }

    public Integer getCount() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return atomicInteger.incrementAndGet();
    }

    public static void main(String[] args) {
        ThreadTest t = new ThreadTest(); 
        new Thread(t).start();
        new Thread(t).start();
    }

}

CAS无锁技术（Compare And Swap）：

翻译过来为：比较再交换

本地内存中存放共享内存的副本

比如主内存中有i=0，复制到两个线程的本地内存中

两个线程执行了i++，本地内存都变成i=1，然后刷新入主内存

CAS算法：

它包含三个参数CAS(V,E,N):

V表示要更新的变量（主内存）

E表示预期值（本地内存）

N表示新值（新值）

仅当V值等于E值时（主内存=本地内存），才会将V的值设为N

如果V值和E值不同（主内存!=本地内存），则说明已经有其他线程做了更新，则当前线程什么都不做

最后，CAS返回当前V的真实值。

观察原子类的源码：

    /** 
     * Atomically increments by one the current value. 
     * 
     * @return the updated value 
     */  
    public final int incrementAndGet() {  
        for (;;) {  
            //获取当前值  
            int current = get();  
            //设置期望值  
            int next = current + 1;  
            //调用Native方法compareAndSet，执行CAS操作  
            if (compareAndSet(current, next))  
                //成功后才会返回期望值，否则无线循环  
                return next;  
        }  
    }  

CAS无锁机制的缺点：

1.死循环

2.ABA问题：如果变量V初次读取的时候是A，并且在准备赋值的时候检查到它仍然是A，那能说明它的值没有被其他线程修改过了吗

（如果在这段期间曾经被改成B，然后又改回A，那CAS操作就会误认为它从来没有被修改过。针对这种情况，java并发包中提供了一个带有标记的原子引用类AtomicStampedReference，它可以通过控制变量值的版本来保证CAS的正确性。）

JVM数据同步：采用分布式锁

自旋锁和互斥锁的区别：

悲观和乐观锁的区别，自旋锁是死循环不会阻塞，互斥锁是同一时间只有一个线程访问数据