单例模式

/**
 * 懒汉式单例1
 * 事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效
 * 没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton1 实例
 */
public class Singletion1 {
    //第一步先将构造方法私有化
    private Singletion1(){}
    // 然后声明一个静态变量保存单例的引用
    private static Singletion1 singletion1 = null;
    //通过提供一个静态方法来获得单例的引用
    public static Singletion1 getInstance(){
        if (singletion1==null){
            singletion1 = new Singletion1();
        }
        return singletion1;
    }
}

 测试：

public class ExectorThread implements Runnable {
    @Override
    public void run() {
        LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+":"+singleton);
    }
}

public class LazySimpleSingletonTest {
    public static void main(String[] args){
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        System.out.println("end");
        //end
        //Thread-0:com.vip.singleton.lazy.LazySimpleSingleton@c6dfc63
        //Thread-1:com.vip.singleton.lazy.LazySimpleSingleton@29b4bc88

//        一定几率出现创建两个不同结果的情况，意味着上面的单例存在线程安全隐患
    }
}

单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式

懒汉式单例的特点是:被外部类调用的时候内部类才会加载

/**
 *懒汉式单例.保证线程安全
 *
 */
public class Singletion2 {
    private Singletion2() {}

    private static Singletion2 singleton2 = null;

    //为了保证多线程环境下正确访问，给方法加上同步锁synchronized
    //虽然线程安全了，但是每次都要同步，会影响性能
//    public static synchronized Singletion2 getInstance(){
//        if (singleton2==null){
//            singleton2 = new Singletion2();
//        }
//        return singleton2;
//    }


    //为了保证多线程环境下的另一种实现方式，双重锁检查
    //做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
　　　//双重检查锁的单例模式

    public static Singletion2 getInstance(){
        if (singleton2 ==null){
            synchronized (Singletion2.class){
                if (singleton2==null){
                    singleton2 = new Singletion2();
                }
            }
        }
        return singleton2;
    }
}

方法加上同步锁synchronized调试：

当我们将其中一个线程执行并调用 getInstance()方法时，另一 个线程在调用 getInstance()方法，线程的状态由 RUNNING 变成了 MONITOR,出现阻 塞。直到第一个线程执行完，第二个线程才恢复 RUNNING 状态继续调用 getInstance() 方法

/**
 *线程安全问题
 */
public class Singletion2Test {
    String name = null;

    private Singletion2Test(){}

    //volatile关键字来声明单例对象
    //方便编写多线程程序和利于编译器进行优化
    private static volatile Singletion2Test  singletion2Test = null;

    public static Singletion2Test getInstance(){
        if (singletion2Test == null){
            synchronized (Singletion2Test.class){
                if (singletion2Test == null){
                    singletion2Test = new Singletion2Test();
                }
            }
        }
        return singletion2Test;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void printInfo(){
        System.out.println(name);
    }
    public static void main(String[] args){
        Singletion2Test instance = Singletion2Test.getInstance();
        instance.setName("abc");
        Singletion2Test instance2 = Singletion2Test.getInstance();
        instance.setName("def");

        instance.printInfo();
        instance2.printInfo();
        System.out.println(instance==instance2);
    }
}

/**
 * 静态内部类
 * 兼顾饿汉式的内存浪费，也兼顾 synchronized 性能问题 ,完美地屏蔽了这两个缺点
 */
public class LazyInnerClassSingleton {
    //默认使用 LazyInnerClassGeneral 的时候，会先初始化内部类
    //如果没使用的话，内部类是不加载的
    private LazyInnerClassSingleton(){}
    //static 是为了使单例的空间共享
    //保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
        //在返回结果以前，一定会先加载内部类
        return LazyHolder.LAZY;
    }

    //默认不加载
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
} 

饿汉式单例：

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线 程还没出现以前就是实例化了，不可能存在访问安全问题。

优点:没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。

缺点:类加载的时候就初始化，不管用与不用都占着空间，浪费了内存

/**
 *饿汉式单例
 * 在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的
 */
public class Singletion4 {
    private Singletion4(){}

    //声明静态变量，在类实例化之前就初始化变量,将对象引用保存
    private static final Singletion4 SINGLETION = new Singletion4();

    public static Singletion4 getInstance(){
        return SINGLETION;
    }
}

//饿汉式静态块单例
public class HungryStaticSingleton {
    private HungryStaticSingleton(){}
    private static HungryStaticSingleton hungryStaticSingleton= null;
    static {
        hungryStaticSingleton = new HungryStaticSingleton();
    }
    public static HungryStaticSingleton getInstance(){
        return hungryStaticSingleton;
    }
}

/**
 * 饿汉式
 * 枚举式单例
 *不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
 */
import java.io.Serializable;

public enum EnumSingleton implements Serializable {
    Instance;
    public static EnumSingleton getInstance(){
        return Instance;
    }
}

　　

import java.util.HashMap;
import java.util.Map;

/**
 *登记式单例
 * 内部实现还是用的饿汉式单例，因为其中的static方法块，它的单例在类被装载的时候就被实例化了
 * 维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回
 */
public class Singletion6 {
    private static Map<String,Singletion6> map = new HashMap<>();

    static {
        Singletion6 singletion6 = new Singletion6();
        map.put(singletion6.getClass().getName(),singletion6);
    }
    protected Singletion6(){}

    public static Singletion6 getInstance(String name){
        if (name==null){
            name = Singletion6.class.getName();
        }
        if (map.get(name)==null){
            try {
                map.put(name, (Singletion6) Class.forName(name).newInstance());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
}

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;

/**
 *CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行
 *
 * 与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
 *
 * 其他N 个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，
 * 他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；
 * 每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调 用了这个方法，count的值等于0，
 * 然后主线程就能通过await()方法，恢复执行自己的任务。
 */
public class Test {
    public static void main(String[] args){
        CountDownLatch latch = new CountDownLatch(100);
        Set<Singletion3> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
        for (int a=0;a<100;a++){
            new Thread(){
                @Override
                public void run() {
                    synchronizedSet.add(Singletion3.getInstance());
                }
            }.start();
            latch.countDown();
        }

        try {
            latch.await();//等待所有线程全部完成，最终输出结果
            System.out.println(synchronizedSet.size());//1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

防止反序列化方式二（方式一请看枚举）：

import java.io.Serializable;

/**
 * 序列化会通过反射调用无参数的构造方法创建一个新的对象
 */
public class SerSingleton implements Serializable {
    String name;

    public SerSingleton() {
        System.out.println("Singleton is create");
        name = "SerSingleton";
    }
    private static SerSingleton instance = new SerSingleton();
    public static SerSingleton getInstance(){
        return instance;
    }
    public static void createString(){
        System.out.println("createString in Singleton");
    }

    //java.io.ObjectInputStream.readOrdinaryObject 方法中的invokeReadResolve会通过反射的方式调用要被反序列化的类的readResolve方法
    //在反序列化后，去掉会生成多个对象实例
    private Object readResolve(){ //阻止生成新的实例，总是返回当前对象
        return instance;
    }
}

//测试

import com.mod.SerSingleton;

import java.io.*;

public class SerSingletonTest {
    public static void main(String[] args) throws Exception {
        SerSingleton s1 = null;
        SerSingleton s = SerSingleton.getInstance();
        FileOutputStream fos = new FileOutputStream("SerSingleton.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s);
        oos.flush();
        oos.close();
        FileInputStream fis = new FileInputStream("SerSingleton.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        s1 = (SerSingleton) ois.readObject();
        //判断是否是同一个对象
        System.out.println(s1==s);
    }
}

readResolve原理分析：

JDK 的源码->ObjectInputStream 类的 readObject()方法

 

在 readObject 中又调用了我们重写的 readObject0()方法。进入 readObject0() 方法，代码如下:

  case TC_OBJECT:
                    return checkResolve(readOrdinaryObject(unshared));

调用了 ObjectInputStream 的 readOrdinaryObject() 方法，我们继续进入看源码:

  readResolveMethod = getInheritableMethod(
                        cl, "readResolve", null, Object.class);

通过 JDK 源码分析我们可以看出，虽然，增加 readResolve()方法返回实例，解决了单 例被破坏的问题。但是，我们通过分析源码以及调试，我们可以看到实际上实例化了两 次，只不过新创建的对象没有被返回而已。那如果，创建对象的动作发生频率增大，就 意味着内存分配开销也就随之增大

防止反射破坏单例：

　　方式一：构造器判断

public class StaticSingleton{
    private StaticSingleton() {
        System.out.println("StaticSingleton is create");
        if (SingletonHolder.instance!=null){
            throw new IllegalStateException();
        }
    }
    private static class SingletonHolder{ //构造器判断，防止反射攻击
        private static StaticSingleton instance = new StaticSingleton();
    }
    public static final StaticSingleton getInstance(){
        return SingletonHolder.instance;
    }
}


import java.lang.reflect.Constructor;

/**
 * 反射测试
 */
public class SerSingletonTest2 {
    public static void main(String[] args) throws Exception {
        Class clazz = StaticSingleton.class;
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        StaticSingleton instance = (StaticSingleton) constructor.newInstance();
        StaticSingleton instance2 = StaticSingleton.getInstance();
        System.out.println(instance==instance2);
    }
}

　　方式二：枚举

/**
 * 反射测试
 */
public class SerSingletonTest2 {
    public static void main(String[] args) throws Exception {
        Class clazz = EnumSingleton.class;//枚举单例
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        EnumSingleton instance = (EnumSingleton) constructor.newInstance();
        EnumSingleton instance2 = EnumSingleton.getInstance();
        System.out.println(instance==instance2);
    }
    //Exception in thread "main" java.lang.NoSuchMethodException: com.mod.EnumSingleton.<init>()
    //	at java.lang.Class.getConstructor0(Class.java:3082)
    //	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    //	at com.Test.SerSingletonTest2.main(SerSingletonTest2.java:15)
}

　　

注册式单例:

注册式单例又称为登记式单例，就是将每一个实例都登记到某一个地方，使用唯一的标 识获取实例。注册式单例有两种写法:一种为容器缓存，一种为枚举登记

在 JDK 枚举的语法特殊性，以及反射也为枚举保 驾护航，让枚举式单例成为一种比较优雅的实现

public enum EnumSingletion {
    INTERFACE;
    private Object data;
    public static EnumSingletion getInstance(){
        return INTERFACE;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}

测试：

public class SerializableSingletionTest {
    public static void main(String[] args){
//        HungrySingleton s1 = null;
//        HungrySingleton s2 = HungrySingleton.getInstance();

        EnumSingletion s1 = null;
        EnumSingletion s2 = EnumSingletion.getInstance();
        s2.setData("1");

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
//            s1 = (HungrySingleton)ois.readObject();
            s1 = (EnumSingletion)ois.readObject();
            ois.close();
            System.out.println(s1.getData()); System.out.println(s2.getData()); System.out.println(s1.getData() == s2.getData());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

容器缓存的写法:

//注册式单例 -- 容器缓存的写法
public class ContainerSingleton {
    private ContainerSingleton(){}
    private static Map<String,Object> map = new ConcurrentHashMap<>();
    public static Object getBean(String className){
        if (!map.containsKey(className)){
            Object object = null;
            try {
                 object = Class.forName(className).newInstance();
                 map.put(className,object);
            }catch (Exception e){
                e.printStackTrace();
            }
            return object;
        }else {
            return map.get(className);
        }
    }
}

容器式写法适用于创建实例非常多的情况，便于管理。但是，是非线程安全的

ThreadLocal 线程单例:

//ThreadLocal 线程单例
public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> instance =
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };
    private ThreadLocalSingleton(){}
    public static ThreadLocalSingleton getInstance(){
        return instance.get();
    }
}

测试：

public class ExectorThread implements Runnable {
    @Override
    public void run() {
        ThreadLocalSingleton singleton = ThreadLocalSingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+":"+singleton);
    }

}

public class ThreadLocalSingletonTest {
    public static void main(String[] args){
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());

        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        System.out.println("end");
        //com.vip.singleton.ThreadLocalSingleton@4b67cf4d
        //com.vip.singleton.ThreadLocalSingleton@4b67cf4d
        //com.vip.singleton.ThreadLocalSingleton@4b67cf4d
        //com.vip.singleton.ThreadLocalSingleton@4b67cf4d
        //Thread-0:com.vip.singleton.ThreadLocalSingleton@5a67a4e
        //end
        //Thread-1:com.vip.singleton.ThreadLocalSingleton@17141277
    }
}

ThreadLocal 不能保证其 创建的对象是全局唯一，但是能保证在单个线程中是唯一的，天生的线程安全

ThreadLocal 将所有的对象全部放在 ThreadLocalMap 中，为每个线程都提供一个对象，实际上是以 空间换时间来实现线程间隔离的。