Java 单例模式

一、单例模式

Java的单例模式是一种常见的设计模式
单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
单例模式的适用场景：
1.对于那种经常实例化但是过一会儿就被销毁的对象适合使用单例模式。
2.对于创建对象需要消耗很多资源的对象。如：数据库连接池对象，线程池对象等
3.只需要一个对象保证全局的一致性的。如：Android中Application对象，网站的计数器等。

二、饿汉模式与懒汉模式

1. 饿汉式

直接创建对象，不存在线程安全问题。

 class Test{
    private static Testmodle = new Test();//声明对象同时私有化
    private Test(){}//构造函数私有化
    public static getInstance(){//向外声明访问该类对象的方法
        return modle;
    }
}

//静态常量写法
/*优点：这种写法比较简单，就是在类加载的时候就完成实例化。避免了线程同步问题。
缺点：在类加载的时候就完成实例化，没有达到Lazy Loading的效果。如果从未使用过这个实例，则会造成内存的浪费。*/
// 方法一
public class SingleTon {
    public static final SingleTon singleTon = new SingleTon();
    private SingleTon(){
    }
}
//方法二
public class SingleTon {
    private static final SingleTon singleTon = new SingleTon();
    private SingleTon(){
    }
	public static SingleTon getInstance(){
		return singleTon;
	}
}

// 静态代码块方式
/*将类实例化的过程放在了静态代码块中，也是在类加载的时候，就执行静态代码块中的代码，初始化类的实例。
优缺点和上面的方式是一样的。*/
//饿汉式：静态代码块
public class SingleTon {
    private static SingleTon singleTon;
    // 在静态代码块执行时，创建单例对象
    static {
        singleTon = new SingleTon();
    }
    private SingleTon(){}
    public static SingleTon getInstance(){
        return singleTon;
    }
}

// 枚举形式
/* 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而
且还能防止反序列化重新创建新的对象。
这种方式是Effective Java作者Josh Bloch 提倡的方式
结论：推荐使用 */
/*
* 枚举类型：表示该类型的对象是有限的几个
* 我们可以限定为一个，就成了单例
*/
public enum SingleTon {
    INSTANCE;
}

*是否 Lazy 初始化：否
*是否多线程安全：是
*实现难度：易
*描述：这种方式比较常用，但容易产生垃圾对象。
*优点：没有加锁，执行效率会提高。
*缺点：类加载时就初始化，浪费内存。
*它基于 classloder 机制避免了多线程的同步问题，
* 不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，
* 在单例模式中大多数都是调用 getInstance 方法，
* 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
* 这时候初始化 instance 显然没有达到 lazy loading 的效果。

2.懒汉模式

延迟创建对象（有的方式存在线程安全问题）。

// 线程不安全方式
/* 起到了Lazy Loading的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以 在多线程环境下不可使用这种方式。
结论：在实际开发中，不要使用这种方式.*/
public class SingleTon {
    private SingleTon(){}
    private static SingleTon singleTon;
    //当调用getSingleTon，才创建单例对象，懒汉式
    public static SingleTon getInstance(){
        if (singleTon == null){
            singleTon = new SingleTon();
        }
        return singleTon;
    }
}

// 双重检查
/* 双重检查概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
这样，实例化代码只会执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象，也避免的反复进行方法同步.
线程安全；延迟加载；效率较高
结论：在实际开发中，推荐使用这种单例设计模式 */ 
public class SingleTon {
    private static volatile SingleTon singleTon;
    private SingleTon(){
    }
    public static SingleTon getInstance(){
        if (singleTon == null){
            synchronized (SingleTon.class){
                if (singleTon == null)
                    singleTon = new SingleTon();
            }
        }
        return singleTon;
    }
}
// 静态内部类形式
/*这种方式采用了类加载的机制来保证初始化实例时只有一个线程。
静态内部类方式在Singleton类被加载时并不会立即实例化，而是在需要实例化
时，调用getSingleTon方法，才会加载Inner类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们
保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
结论：推荐使用.*/
//懒汉式：静态内部类形式
public class SingleTon {
    private SingleTon(){   
    }
    private static class Inner{
        private static final SingleTon SINGLE_TON = new SingleTon();
    }
    public static SingleTon getInstance(){
        return Inner.SINGLE_TON;
    }
}

 *是否 Lazy 初始化：是
 *是否多线程安全：是
 *实现难度：易
 *描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
 *优点：第一次调用才初始化，避免内存浪费。
 *缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
 *getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

三、懒汉式和饿汉式区别

1. 实例化方面：懒汉式默认不会实例化，外部什么时候调用什么时候new。饿汉式在类加载的时候就实例化，并且创建单例对象。
2. 线程安全方面：饿汉式线程安全 (在线程还没出现之前就已经实例化了，因此饿汉式线程一定是安全的)。懒汉式线程不安全( 因为懒汉式加载是在使用时才会去new 实例的，那么你去new的时候是一个动态的过程，是放到方法中实现的。如果这个时候有多个线程访问这个实例，这个时候实例还不存在，还在new，就会进入到方法中，有多少线程就会new出多少个实例。一个方法只能return一个实例，那最终return出哪个呢？是不是会覆盖很多new的实例？这种情况当然也可以解决，那就是加同步锁，避免这种情况发生) 。
3. 执行效率上：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。
4. 性能上：饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，所以会占据空间，浪费内存。懒汉式什么时候需要什么时候实例化，相对来说不浪费内存。