设计模式之单例模式

1. 设计模式的概念
   设计模式其实就是一套被反复使用的，很多人都知晓的对代码的设计的一种总结，一种思想，提高了程序员的开发效率
2. 单例模式
   ①定义：在整个程序开发过程中，产生的对象有且仅有一个
   ②分类：饿汉式和懒汉式
   ③饿汉式：特点：在类加载的时候，比较慢，因为它需要创建对象，而在运行时，是比较快的，因为对象已经创建完毕，只是需要调用而已，它创建的单例对象是线程安全的。
   代码和测试如下：

public class Singleton {
    //私有化构造器，不让外部通过构造器来创建对象，防止创建多个对象
    private Singleton(){        
    }
    //根据封装性，将对象属性访问权限修饰为私有的，在类加载的时候就创建好了一个对象，整个工程就这一个对象
    private static Singleton singletonInstance = new Singleton();

    //提供一个对外开放的方法来获取对象
    public static Singleton getInstance() {
        return singletonInstance;
    }   
}

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        if (singleton == singleton2) {
            System.out.println("singletion对象和singletion2对象是一个对象");
        }else {
            System.out.println("singletion对象和singletion2对象不是一个对象");
        }
    }

④懒汉式：特点：类加载时比较快，因为它只是在类加载的时候，声明了对象的引用，而在运行时的时候，比较慢，因为在运行时，程序需要创建一个对象，所以运行的才慢点，但是原始的懒汉式单例模式是线程不安全的，如果要解决线程不安全问题，就需要给其加锁
原始的懒汉式代码和测试如下：

public class Singleton {
    //私有化构造器，不让外部通过构造器来创建对象，防止创建多个对象
    private Singleton(){        
    }
    //在类加载的时候不创建对象，在运行时需要该对象的时候在创建
    private static Singleton singletonInstance = null;

    //提供一个对外开放的方法来获取对象
    public static Singleton getInstance() {

        if (singletonInstance == null) {
            singletonInstance = new Singleton();
        }
        return singletonInstance;
    }   
}

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        if (singleton == singleton2) {
            System.out.println("singletion对象和singletion2对象是一个对象");
        }else {
            System.out.println("singletion对象和singletion2对象不是一个对象");
        }
    }

下面展示懒汉式线程不安全的问题，及一种简单的解决方法

public class TestSingletion {
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Singleton singleton = Singleton.getInstance();
                    System.out.println(singleton);
                }
            }).start();            
        }
    }
}

解决方法加了一个synchronized锁

“`
public class Singleton {
//私有化构造器，不让外部通过构造器来创建对象，防止创建多个对象
private Singleton(){
}
//在类加载的时候不创建对象，在运行时需要该对象的时候在创建
private static Singleton singletonInstance = null;

//提供一个对外开放的方法来获取对象
public static Singleton getInstance() {
    if (singletonInstance == null) {
      //同步代码块用的锁是单例的字节码文件对象，且只能用这个锁
        synchronized (Singleton.class) {
            if (singletonInstance == null) {
                singletonInstance = new Singleton();
            }
        }
    }
    return singletonInstance;
}   

}“`

问题解决了，通常在项目开发过程中，由于代码比较多，锁的方式影响效率，大多采用的是饿汉式单例模式