单例模式

单件：

独一无二，他是利用单件模式构造出来的，这个模式让让他在任何时刻都是只有一个对象，比如：如果注册表设置的对象，不想这样的对象有多个拷贝，就可以用单例模式，确保程序中使用的全局资源只有一份。

常常被用来管理共享资源，例如数据连接或者线程池

单例类拥有以下几个要素：

• 私有构造方法(保证客户端无法去实例化该对象)
• 指向自己实例的私有静态引用
• 以自己实例为返回值得静态的共有的方法

单例模式分类

A、懒汉单例模式：在第一次调用的时候实例化本身，在并发环境下，可能出现多个本身对象。所以线程是不安全的

B、饿汉单例模式：在类初始化时，已经自行实例化一个静态对象，所以本身就是线程安全的

C、登记单例模式：通过一个专门的类对各单例模式的单一实例进行管理和维护

详细说明 （推荐饿汉式）

1.懒汉写法：如果getInstance()的性能对应用程序不是很关键，就什么都别做</p>

public class Singleton_1 {

    public static void main(String[] args) {
        Singleton_1 singleton_11 = Singleton_1.getSingleton_1();
        Singleton_1 singleton_12 = Singleton_1.getSingleton_1();
        System.out.println(singleton_11);
        System.out.println(singleton_12);
    }
    private  static Singleton_1 singleton_1 = null;

    private Singleton_1(){}

    public static Singleton_1 getSingleton_1(){
        if (singleton_1 == null){
            singleton_1 = new Singleton_1();
        }
        return  singleton_1;
    }
}

这种方式在多线程的情况下并不实用
下面测试：

/**
 * Singleton 这种方式之适合单线程的状态
 * com.offer.demo.singleton.Singleton_1@5c25cea
 * com.offer.demo.singleton.Singleton_1@3c13f478
 * com.offer.demo.singleton.Singleton_1@3c13f478
 */
public class Singleton_1_Test {
    public static void main(String[] args) {
        Thread thead1 = new Thread(new Runnable() {
            public void run() {
                Singleton_1  singleton_1 =Singleton_1.getSingleton_1();
                System.out.println(singleton_1);
            }
        });

        Thread thead2 = new Thread(new Runnable() {
            public void run() {
                Singleton_1  singleton_2 =Singleton_1.getSingleton_1();
                System.out.println(singleton_2);
            }
        });
        Thread thead3 = new Thread(new Runnable() {
            public void run() {
                Singleton_1  singleton_3 =Singleton_1.getSingleton_1();
                System.out.println(singleton_3);
            }
        });

        thead1.start();
        thead2.start();
        thead3.start();

    }
}

2.使用急切创建实例，而不是用延迟实例化的方法。这种方式也叫做饿汉式的单例模式

public class Singleton_2 {

    public static void main(String[] args) {

        Singleton_2 singleton_1 = Singleton_2.getSingleton_2();
        Singleton_2 singleton_12 = Singleton_2.getSingleton_2();
        System.out.println(singleton_1);
        System.out.println(singleton_12);
    }

    private  static Singleton_2 singleton_2 = new Singleton_2();

    private Singleton_2(){}

    public static Singleton_2 getSingleton_2(){
        return singleton_2;
    }
}

测试类：

/**
 * 饿汉式适合多线程的情况
 *
 * com.offer.demo.singleton.Singleton_2@7bddc905
 * com.offer.demo.singleton.Singleton_2@7bddc905
 * com.offer.demo.singleton.Singleton_2@7bddc905
 */
public class Singleton_2_Test {
    public static void main(String[] args) {
        Thread thead1 = new Thread(new Runnable() {
            public void run() {
               Singleton_2 singleton_1 = Singleton_2.getSingleton_2();
                System.out.println(singleton_1);
            }
        });

        Thread thead2 = new Thread(new Runnable() {
            public void run() {
                Singleton_2  singleton_2 =Singleton_2.getSingleton_2();
                System.out.println(singleton_2);
            }
        });
        Thread thead3 = new Thread(new Runnable() {
            public void run() {
                Singleton_2  singleton_3 =Singleton_2.getSingleton_2();
                System.out.println(singleton_3);
            }
        });

        thead1.start();
        thead2.start();
        thead3.start();

    }
}

3.用"双重检查加锁"，首先检查是否实例已经创建，如果尚未创建，才进行同步，这里一来，只有第一次同步，这正是我们想要的。

1. public class SingletonTest3 {
  2.    //在静态初始化器中创建单例，这段代码保证了线程安全
  3.    private volatile static SingletonTest3 uniqueInstance;
  4.     //这里吧构造器申明为私有的，只有自Singleton类内才可以调用构造器
  5.     private SingletonTest3(){}
  6.     //用getInstance方法实例化对象，并返回这个实例
  7.     public static SingletonTest3 getInstance(){
  8.        if(uniqueInstance==null){
  9.            synchronized (SingletonTest3.class){
  10.        if(uniqueInstance ==null){
  11.              uniqueInstance=new SingletonTest3();
  12.          }}}
  13.        //已经有了实例了，直接使用它。
  14.         return uniqueInstance;
  15.     }
  16. }

4.类加载的方式：延迟加载，线程安全，同步情况下效率高，不要进行同步控制，实现简单，不能防止反序列化

1. package designpattern.signleton;
  2. /**
      单例模式，类加载方式
  8.  */
  9. public class SingletonTest4 {
  10.   
  11.    //这里吧构造器申明为私有的，只有自Singleton类内才可以调用构造器
  12.     private SingletonTest4(){}
  13.    
  14.     //静态内部类，用于持有唯一的SingletonClass的实例
  15.     private static class OnlyInstance{
  16.       static private SingletonTest4 ONLY=new SingletonTest4();
  17.     }
  18.     
  19.     public static SingletonTest4 getInstance(){
  20.       return OnlyInstance.ONLY;
  21.     }
  22. }

5.枚举方式：立即加载，线程安全，实现简单，防止反序列化。

1. public enum SingletonTest5 {
  2.    
  3.    INSRANCE;
  4.    public void f(){
  5.    }
  6. }