java 单例的实现及多线程下的安全

package com.demo01;

public class Single {

	/**
	 * 设计模式：单例设计模式
	 * 		解决一个类中只允许存在一个对象这种情况；
	 * 		不允许通过类，无限制的创建该类的对象。
	 * 	怎样实现单例模式？
	 * 		构造函数私有化(private);
	 * 		在当前类的内部，写一个方法创建出该类的对象；
	 * 		对外提供公共的访问接口；
	 * */
	public static void main(String[] args) {

	}

}
/*
 * 枚举enum实现单例模式
 * 多线程下安全
 */
class ClassFactory{
    private enum MyEnumSingleton{
        singletonFactory;  

        private MSingleton instance;  

        private MyEnumSingleton(){//枚举类的构造方法在类加载是被实例化
            instance = new MSingleton();
        }  

        public MSingleton getInstance(){
            return instance;
        }
    }
    public static MSingleton getInstance(){
        return MyEnumSingleton.singletonFactory.getInstance();
    }
}
//需要获实现单例的类，比如数据库连接Connection
class MSingleton{
    public MSingleton(){}
} 

/*
 * 内部类方式实现单例
 * 多线程是安全
 */

 class MySingleton {  

    //静态内部类
    private static class MySingletonHandler{
        private static MySingleton instance = new MySingleton();
    }
    private MySingleton(){}
    public static MySingleton getInstance() {
        return MySingletonHandler.instance;
    }
} 

/*
 * 懒汉式：
 * 在需要用的时候才创建对象
 * 多线程下微调后，多线程下，无法保证实例唯一的，
 */
class Singer2{
	private Singer2(){}
	private static Singer2 createSinger = null;
	//创建单例，
	public static Singer2 getInstance(){
		if(createSinger == null){
			try {
				Thread.sleep(200);
				createSinger = new Singer2();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
		return createSinger;
	}

}
/*
 * 懒汉式 方法加锁实现线程同步
 * 加锁后效率低
 */

class Singer3{
	private Singer3(){}
	private static Singer3 createSinger = null;
	//创建单例，synchronized加锁
	public static synchronized Singer3 getInstance(){
		if(createSinger == null){
			try {
				Thread.sleep(200);
				createSinger = new Singer3();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		return createSinger;
	}

}
/*
 * 懒汉式   同步代码块实现
 * 效率低
 */
class Singer5{
	private Singer5(){}
	private static Singer5 createSinger = null;
	//创建单例，synchronized加锁
	public static  Singer5 getInstance(){
		try {
			synchronized (Singer5.class) {
				if(createSinger == null){
					Thread.sleep(200);
					createSinger = new Singer5();
				}
			}
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
		return createSinger;
	}

}
/*
 * 懒汉式：
 * 双检查锁机制DCL(double check lock)
 * 销量和同步并存
 */
class Singer1{
	private Singer1(){}
	private static Singer1 createSinger = null;
	//创建单例，synchronized加锁
	public static  Singer1 getInstance(){
		try {
			if(createSinger == null){
				Thread.sleep(200);
			synchronized (Singer1.class) {
				if (createSinger==null) {
					createSinger = new Singer1();
				}
				}
			}
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
		return createSinger;
	}

}

/*
 * 俄汉式
 * 开始就产生了对象。对于项目中从开始到结束都没有用到的对象，会造成资源浪费
 * 多线程下测试安全，是同一个实例
 */
class Singer4{
    private static Singer4 instance = new Singer4();
    private Singer4(){}
    public static Singer4 getInstance(){
    	try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
      return instance;
 }
} 

多线程下的测试代码

package com.demo01;

public class MyThread extends Thread{  

    public void run() {
        System.out.println(ClassFactory.getInstance().hashCode());
    }  

    public static void main(String[] args) {   

        MyThread[] mts = new MyThread[10];
        for(int i = 0 ; i < mts.length ; i++){
            mts[i] = new MyThread();
        }  

        for (int j = 0; j < mts.length; j++) {
            mts[j].start();
        }
    }
}