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();  
        }  
    }  
}