锁机制

1.锁是干什么用的
　　锁一般来说用作资源控制，限制资源访问，防止在并发环境下造成数据错误

2.重入锁
　　重入锁也叫作递归锁，指的是同一个线程外层函数获取到一把锁后，内层函数同样具有这把锁的控制权限
　　synchronized和ReentrantLock就是重入锁对应的实现
　　synchronized重量级的锁
　　ReentrantLock轻量级的锁 lock()代表加入锁 unlock()代表释放锁

　　不可重入锁：说明当没有释放该锁时。其他线程获取该锁会进行等待

public class MyLock {
    //标识锁是否可用  如果值为 true代表有线程正在使用该 锁 ，如果为false代表没有人使用锁
    private boolean isLocked=false;
    //获取锁：加锁
    public synchronized void lock() throws InterruptedException {
        //判断当前该锁是否正在使用
        while (isLocked){
            wait();
        }
        //当前没有人使用情况 下就占用该锁
        isLocked=true;
    }

    //释放锁
    public synchronized  void unLock(){
        //将当前锁资源释放
        isLocked=false;
        //唤起正在等待使用锁的线程
        notify();
    }

}

public class MyLockTest {

MyLock myLock=new MyLock();
    //A业务
    public void print() throws InterruptedException {
        //获取一把锁
        myLock.lock();
        System.out.println("print业务方法");
        doAdd();
        //释放锁
        myLock.unLock();
    }
    //B业务方法
    public void  doAdd() throws InterruptedException {
        //获取一把锁
        myLock.lock();
        System.out.println("aoAdd方法");
        //释放锁
        myLock.unLock();

    }

    public static void main(String[] args) throws InterruptedException {
        MyLockTest myLockTest=new MyLockTest();
        myLockTest.print();
    }
}

　　控制台结果：

当前效果就造成了死锁

　　synchronized可重入性：如果当前A持有一把锁，在A业务内部调用B，那么B也同样拥有这把锁的使用权限

　　编写测试代码：

MyLock myLock=new MyLock();
    //A业务
    public synchronized void print() throws InterruptedException {

        System.out.println("print业务方法");
        doAdd();

    }
    //B业务方法
    public synchronized void  doAdd() throws InterruptedException {

        System.out.println("aoAdd方法");


    }

    public static void main(String[] args) throws InterruptedException {
        MyLockTest myLockTest=new MyLockTest();
        myLockTest.print();
    }

　　控制台结果：

 

　　ReentrantLock同样具有可重入性

　　编写测试代码：

public class MyLockTest {
    //创建锁对象
    Lock lock=new ReentrantLock();
    //A业务
    public void print() throws InterruptedException {
        //获取了一把锁
        lock.lock();
        System.out.println("print业务方法");
        doAdd();
        //释放锁
        lock.unlock();

    }
    //B业务方法
    public void  doAdd() throws InterruptedException {
        //获取一把锁
        lock.lock();
        System.out.println("aoAdd方法");
        //释放锁
        lock.unlock();

    }

    public static void main(String[] args) throws InterruptedException {
        MyLockTest myLockTest=new MyLockTest();
        myLockTest.print();
    }
}

　　控制台结果：

3. 读写锁

　　并发线程下，所有线程都执行读的操作，会不会有问题
　　并发线程下，部分读部分写会不会有问题 会发生写冲突
　　并发线程下，所有线程都执行写会不会有问题 会发生写冲突

　　编写测试代码：

 //创建一个集合
    static Map<String,String> map=new HashMap<String,String>();
    //创建一个读写锁
    static ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
    //获取读锁
    static Lock readLock=lock.readLock();
    //获取写锁
    static Lock writeLock=lock.writeLock();
    //写操作
    public Object put(String key,String value){
        writeLock.lock();
        try {
            System.out.println("Write正在执行写操作~");
            Thread.sleep(100);
            String put = map.put(key, value);
            System.out.println("Write写操作执行完毕~");
            return put;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
        return null;

    }

    //写操作
    public Object get(String key){
        readLock.lock();
        try {
            System.out.println("Read正在执行读操作~");
            Thread.sleep(100);
            String value = map.get(key);
            System.out.println("Read读操作执行完毕~");
            return value;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            readLock.unlock();
        }
        return null;

    }

    public static void main(String[] args) {
        ReadWriteLock lock=new ReadWriteLock();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            new Thread(()->{
                try {
                    //写操作
                    lock.put(finalI +"","value"+finalI);
                    //读操作
                    System.out.println(lock.get(finalI+""));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }

　　控制台 结果：

我们可以看出是当所有写操作都执行完毕后才开始执行读操作

4. 乐观锁

　　总认为不会发生并发问题，每一次取数据时总认为其他线程不会对该数据先进性更改，但是在更新时会判断其他线程在这之前有

　　没有对该数据进行修改，
　　数据库当中常用方案：版本号控制

5.悲观锁
　　总是假设最坏的情况，每次取数据时，都会认为其他线程会对该数据进行修改，所以会进行加锁
　　其他线程访问的时候会阻塞等待，例如在数据库当中可以使用行锁，表锁以及读写锁等方式实现

6. CAS无锁模式

　　6.1  什么 是CAS

　　CAS：Compare and Swap，即比较再交换。

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

　　JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。

　　6.2  Java内存模型：JMM（Java Memory Model）

　　　　在内存模型当中定义了一个主内存，所有声明的实例变量都存在于主内存当中，主内存的数据会共享给所有线程，每一个线程有一块工作内存，工作内存当中主内存数据的副本
　　　　当更新数据时，会将工作内存中的数据同步到主内存当中

　　6.2 CAS无锁机制

　　　　本身无锁，采用乐观锁的思想，在数据操作时对比数据是否一致，如果一致代表之前没有线程操作该数据，那么就会更新数据，如果不一致代表有县城更新则重试
　　CAS当中包含三个参数CAS(V,E,N)，V标识要更新的变量，E标识预期值，N标识新值

　　

　　运行过程：
　　1.线程访问时，先会将主内存中的数据同步到线程的工作内存当中
　　2.假设线程A和线程B都有对数据进行更改，那么假如线程A先获取到执行权限
　　3.线程A先会对比工作内存当中的数据和主内存当中的数据是否一致，如果一致（V==E）则进行更新，不一致则刷新数据，重新循环判断
　　4.这时更新完毕后，线程B也要进行数据更新，主内存数据和工作内存数据做对比，如果一致则进行更新，不一致则将主内存数据重新更新到工作内存，然后循环再次对比两个内存中的数据
　　直到一致为止


　　CAS无锁机制存在一个问题
　　ABA问题，如果将原来A的值改为了B，然后又改回了A，虽然最终结果没有发生改变，但是在过程中是对该数据进行了修改操作
　　解决该问题：在Java中并发包下有一个原子类：AtomicStampedReference，在该类当中通过版本控制判断值到底是否被修改
　　解释：如果对值进行了更改则版本号+1，那么在CAS当中不仅仅对比变量的值，还要对比版本号，如果值和版本号都相等则代表没有被修改，如果有一方不相等代表进行过更改
　　那么就从主内存中重新刷新数据到工作内存然后循环对比，直到成功为止~

　　7.保证线程安全的三个方面：
　　1.原子性：保证同一时刻该资源只能有一个线程访问修改，其他线程阻塞等待，例如Atomic包，锁
　　2.可见性：一个线程对于主内存的数据操作对于其他线程是可见的
　　3.有序性：一个线程观察其他线程中指令执行顺序，由于指令重排序存在，观察结果一般杂乱无序
　　原子性： 互斥访问，Atomic包，CAS算法，Synchronized，Lock

　　可见性：synchronized，volatile

　　顺序性：happends-before

　　8.  原子类

　　　编写测试代码：　　

 //定义一个原子类对象
    private AtomicInteger  atomicInteger=new AtomicInteger();
    public  void getCount(){
        //+1再返回
        System.out.println(atomicInteger.incrementAndGet());
    }

    public static void main(String[] args) {
        AtomicTest atomicTest=new AtomicTest();
        for (int i=1;i<=2;i++){
            new Thread(()->{
                for (int j=1;j<=100;j++){
                    atomicTest.getCount();
                }
            }).start();
        }
    }

　　控制台效果：

　

　　8.AQS:全成AbstractQueueSynchronizer，抽象队列同步器，这个类在java.util.concurrent.locks包下
　　　　它是一个底层同步工具类，比如CountDownLatch,Sammphore，ReentrantLock,ReentrantReadWriteLock等等都是基于AQS
　　　　底层三个内容：
　　　　1.state（用于计数器）
　　　　2.线程标记（哪一个线程加的锁）
　　　　3.阻塞队列（用于存放阻塞线程）