单例模式

问题

我们的工程中存在唯一存在的对象，比如一些共享资源啥的。今天就介绍单例模式。

饿汉模式

/**
*  单例模式 饿汉模式
*/
public class Singleton {

    private static  final Singleton instance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }

}

单例里面的饿汉模式，见名思义。就是当这个类加载的时候就进行实例化，在使用的时候就不会出现并发而创建两个对象的情况。

懒汉模式

/**
*  懒汉模式 synchronized method
*/
public class Singleton_2 {

    private static  Singleton_2 instance;

    private Singleton_2(){}


    public  synchronized static  Singleton_2 getInstance(){
        if(instance == null){
            instance = new Singleton_2();
        }
        return instance;
    }
}

懒汉模式1：和名字一样，只用在使用的时候才会被加载到，这个时候就会出现多个线程创建的问题，使用synchronized的方法，锁住方法进入的时候。

/**
* <PRE>
*  单例模式 懒汉模式
* </PRE>
*/
public class Singleton_3 {

    private volatile static Singleton_3 instance;

    private Singleton_3(){}

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

懒汉模式2：也有懒汉模式的通病，使用的更加优化，并没有直接锁到整个方法，而是在创建的时候才会去锁，其他的时候不会进行锁的操作。

比较

名称	优点	缺点
饿汉模式	不用进行考虑并发所造成的问题	在加载该类的时候就开始初始化该类的内容，但是如果了该类没有频繁的是使用，造成内存的浪费。
懒汉模式1	使用的时候进行加载，不会造成内存的浪费	锁放在方法上面，虽然也可以上锁，但是多个线程进入方法是竞争的状态，会造成阻塞，但仅仅只是在创建的时候进行阻塞就行。并发运行效率不高
懒汉模式2	使用的时候进行加载，不会造成内存的浪费	锁在创建的代码上面，不会影响到方法的进入，是一个比较优的选择，但是如果该类的大小不大，还是建议使用饿汉模式