设计模式之单例模式及应用demo

单例模式是创建型模式之一。

单例模式顾名思义是单例的，也就是只有一个实例化对象，这都来源于它的私有化构造函数。

单例模式特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例

单例模式的应用场景：Windows的Task Manager（任务管理器）；网站的计数器； 多线程的线程池的设计； Web应用的配置对象的读取（由于配置文件是共享的资源）。

单例模式的五种实现方法：

在看实现方法之前，要先了解一些java的知识：1、初始化顺序依次是：（静态变量、静态初始化块）–>（普通变量、初始化块）–> 构造器；如果有父类，则顺序是：父类static方法 –> 子类static方法 –> 父类构造方法- -> 子类构造方法 。　　　　　

2、静态变量特点：static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配，后面根据需要是可以再次赋值的。公共性，就是说，一个类的静态成员，它是属于大伙的，所有的类对象共享的，不像成员变量是自己的。

---

1、饿汉模式

public class Singleton {
    // 私有构造
    private Singleton() {}

    private static Singleton instance = new Singleton();

    // 静态工厂方法,方法没有同步块，所以效率高。
    public static Singleton1 getInstance() {
        return  instance;
    }
}

　　饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

2、懒汉模式

public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    //使用的同步锁，降低了效率，但是在多线程可以防止创建多个实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

3、双重检测模式

public class Singleton {
    public static volatile Singleton singleton = null;

    private Singleton(){}

    public static Singleton getInstance(){
        if(singleton == null){
           synchronize (Singleton.class){
               if( singleton == null ) {
                   singleton = new Singleton();
               }
        }
        return singleton;
    }
}

　　当两个线程执行完第一个 singleton == null 后等待锁， 其中一个线程获得锁并进入synchronize后，实例化了，然后退出释放锁，
另外一个线程获得锁，进入又想实例化，会判断是否进行实例化了，如果存在，就不进行实例化了。　

4、静态内部类

public class Singleton {
    // 静态内部类LazyHolder
    private static class LazyHolder {
       private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
       return LazyHolder.INSTANCE;
    }
}　

 此方法既实现了线程安全，又避免了同步带来的性能影响。
还有就是类似的静态代码块实现：

public class Singleton{

    // 私有构造
    private Singleton() {}

    private static Singleton single = null;

    // 静态代码块
    static{
        single = new Singleton();
    }

    public static Singleton getInstance() {
        return single;
    }
}

5、枚举类

public class SingletonFactory {

    // 内部枚举类
    private enum EnmuSingleton{
        Singleton;
        private Singleton singleton;

        //枚举类的构造方法在类加载是被实例化
        private EnmuSingleton(){
            singleton = new Singleton();
        }
        public Singleton getInstance(){
            return singleton;
        }
    }
    public static Singleton getInstance() {
        return EnmuSingleton.Singleton.getInstance();
    }
}

class Singleton{
    public Singleton(){}
}

　下面是一个单例模式使用的demo 饿汉模式

public class TestSingleton {

	String name = null;
	private TestSingleton() {
	}

	private static TestSingleton instance = new TestSingleton();

	public static TestSingleton getInstance() {
           return instance;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void print() {
		System.out.println("the name is " + name);
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		TestSingleton ts1 = TestSingleton.getInstance();
		ts1.setName("12345");
		TestSingleton ts2 = TestSingleton.getInstance();
		ts2.setName("56789");

		ts1.print();
		ts2.print();
		if(ts1 == ts2){
			System.out.println("创建的是同一个实例");
		}else{
			System.out.println("创建的不是同一个实例");
		}

	}

}