JUC（6）单例模式 && CAS

1. 单例模式定义：

• 单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

2.单例模式的几种实现方式

2.1 饿汉式

饿汉式是利用类加载机制来避免了多线程的同步问题，所以是线程安全的。
优点：未加锁，执行效率高。
缺点：类加载时就初始化实例，造成内存浪费。

如果对内存要求不高的情况，还是比较推荐使用这种方式。

package com.lin;

public class SingletonHungry {

    // 因为是getInstance是静态方法，因此开始就被加载进内存，因此有可能会浪费内存空间
    private byte[] data1 = new byte[1024 * 1024];
    private byte[] data2 = new byte[1024 * 1024];
    private byte[] data3 = new byte[1024 * 1024];
    private byte[] data4 = new byte[1024 * 1024];
    
    /**
     * 私有构造方法
     *
     */
    private SingletonHungry (){
    }

    /**
     * 私有实例，静态变量会在类加载的时候初始化，是线程安全的
     */
    private static final SingletonHungry instance=new SingletonHungry();

    /**
     * 唯一公开获取实例的方法（静态工厂方法）
     * @return
     */
    public static SingletonHungry getInstance(){
        return instance;
    }
}

2.2 懒汉式

该方式是使用synchronized关键字进行加锁，保证了线程安全性。
优点：在第一次调用才初始化，避免了内存浪费。
缺点：对获取实例方法加锁，大大降低了并发效率。

由于加了锁，对性能影响较大，不推荐使用。

package com.lin;

public class SingletonLazy {

    /**
     * 私有构造方法
     */
    private SingletonLazy(){

    }

    /**
     * 私有实例
     */
    private static  SingletonLazy singletonLazy ;

	/**
     * 唯一公开获取实例的方法（静态工厂方法），该方法使用synchronized加锁，来保证线程安全性
     *
     * @return
     */
    public static synchronized SingletonLazy getInstance(){
        if(singletonLazy==null){
            singletonLazy = new SingletonLazy();
        }
        return singletonLazy;
    }
}

2.3 DCL双重校验锁

DCL即 double-checked locking相比一般懒汉式，加了 volatile关键字 保证线程之间的同步问题相比加锁的懒汉式，不是在方法前面加synchronized从而影响效率，这种方法效率更高。
利用了volatile修饰符的线程可见性（被一个线程修改后，其他线程立即可见），即保证了懒加载，又保证了高性能，所以推荐使用。

package com.lin;

public class SingletonDCL {

    /**
     * 私有构造方法
     */
    private SingletonDCL(){

    }

    /**
     * 私有实例，volatile修饰的变量是具有可见性的（即被一个线程修改后，其他线程立即可见）
     */
    private static volatile SingletonDCL singletonDCL;

    /**
     * 唯一公开获取实例的方法（静态工厂方法）
     *
     * @return
     */
    public static SingletonDCL getInstance(){
        // 第一次判断，没有实例的时候给类加锁
        if(singletonDCL==null){
            synchronized (SingletonDCL.class){
                // 第二次判断，没有实例的时候 获得单例
                if(singletonDCL==null){
                    singletonDCL=new SingletonDCL();
                }
            }
        }
        return singletonDCL;
    }
}

3. CAS

CAS其实本质是自旋锁。判断是否是当前期望的值，是就更新，不是就一直自旋等待。
例子：

import java.util.concurrent.atomic.AtomicInteger;

public class Demo1 {

    public static void main(String[] args) {
        AtomicInteger num = new AtomicInteger(100);
        // 参数为 (期望值 ,更新后的值)
        num.compareAndSet(100,200);
        System.out.println(num.compareAndSet(200, 300)); // true 更新成功
        System.out.println(num.compareAndSet(200, 300)); // false 更新失败
        System.out.println(num.get());
    }
}

源码：

缺点

• 自旋锁循环会耗时
• 一次性只能保证一个共享变量的原子性
• 会存在ABA问题

4.ABA问题

在两个线程之间穿插了一个线程，将数据改了，但是又改回原来的数据

ABA 问题的解决思路
使用版本号。 在变量前面追加上版本号，每次变量更新的时候把版本号加 1，那么 A→B→A 就会变成 1A→2B→3A。

扩展：

mysql的并发操作时而引起的数据的不一致性（数据冲突）：

丢失更新：两个用户（或以上）对同一个数据对象操作引起的数据丢失。

解决方案：

• 悲观锁，假设丢失更新一定存在；sql后面加上for update；这是数据库的一种机制。
• 乐观锁，假设丢失更新不一定发生。update时候存在版本，更新时候按版本号进行更新。