黑马程序员--单例模式

什么叫单例模式

单例模式（Singleton）是一种常用的设计模式。单例模式，也叫单子模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为

单例模式特点

显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

单例大致分为5种

1.懒汉式

2.恶汉式

3.静态内部类

4.枚举

5.双重校验锁

目前只知道懒汉式和恶汉式  所以只重点总结下这两个啦 

这两种模式的步骤大致相同

1.私有本类的构造方法

2.创建本类对象

3.对外提供访问本类对象的功能

代码体现:

[java] view plain copy print ?

1. //恶汉式:    缺点没有达到Lazy loading的效果  
2. class Single{  
3.     private static Single s = new Single();  
4.     private Single(){  
5.     }  
6.     public static Single getInstance(){  
7.         return s ;  
8.     }  
9. }  

//恶汉式:    缺点没有达到Lazy loading的效果
class Single{
	private static Single s = new Single();
	private Single(){
	}
	public static Single getInstance(){
		return s ;
	}
}

[java] view plain copy print ?

1. //懒汉式    比较常用的写法  
2. class Single2{  
3.     private Single2(){  
4.     }  
5.     private static Single2 instance = null;  
6.     public static Single2 getInstance(){  
7.         if (instance == null){  
8.             instance = new Single2();  
9.         }  
10.         return instance ;  
11.     }  
12. }  

//懒汉式    比较常用的写法
class Single2{
	private Single2(){
	}
	private static Single2 instance = null;
	public static Single2 getInstance(){
		if (instance == null){
			instance = new Single2();
		}
		return instance ;
	}
}

[java] view plain copy print ?

1. //测试类  
2. class SingleTest{  
3.     public static void main(String[] args){  
4.         Single s = Single.getInstance();  
5.         Single s2 = Single.getInstance();  
6.         System.out.println("s="+s);  
7.         System.out.println("s2="+s2);  
8.         System.out.println(s == s2);    //不多说 肯定是true  
9.     }  
10. }  

//测试类
class SingleTest{
	public static void main(String[] args){
		Single s = Single.getInstance();
		Single s2 = Single.getInstance();
		System.out.println("s="+s);
		System.out.println("s2="+s2);
		System.out.println(s == s2);	//不多说 肯定是true
	}
}

这两种实现方式个人觉得懒汉式比较好点   其特点就是需要创建对象的时候才会有,而恶汉式是类一加载就会创建对象

下面再列举其他方式的代码体现

[java] view plain copy print ?

1. //双重校验锁,在当前的内存模型中无效  
2. class LockSingleton{  
3.   
4.     private volatile static LockSingleton singleton;  
5.   
6.     private LockSingleton(){}  
7.   
8.   
9.     public static LockSingleton getInstance(){  
10.   
11.         if(singleton==null){  
12.   
13.             synchronized(LockSingleton.class){  
14.   
15.                 if(singleton==null){  
16.   
17.                     singleton=new LockSingleton();  
18.   
19.                 }  
20.             }  
21.   
22.         }  
23.         return singleton;  
24.   
25.     }  
26.   
27.        
28.   
29. }  

//双重校验锁,在当前的内存模型中无效
class LockSingleton{

    private volatile static LockSingleton singleton;

    private LockSingleton(){}


    public static LockSingleton getInstance(){

        if(singleton==null){

            synchronized(LockSingleton.class){

                if(singleton==null){

                    singleton=new LockSingleton();

                }
            }

        }
        return singleton;

    }

     

}

[java] view plain copy print ?

1. //枚举,  优点: 不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象  
2. enum EnumSingleton{  
3.         INSTANCE;  
4.         public  void doSomeThing(){  
5.         }  
6. }  

//枚举,  优点: 不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象
enum EnumSingleton{
		INSTANCE;
		public  void doSomeThing(){
		}
}

//静态内部类  优点: 加载是不会初始化静态变量INSTANCE,因为没有主动使用,达到Lazyloading(这是啥)

[java] view plain copy print ?

1. class InternalSingleton{  
2.   
3.     private static class SingletonHolder{  
4.   
5.         private final static  InternalSingleton INSTANCE=new InternalSingleton();  
6.   
7.     }    
8.   
9.     private InternalSingleton(){}  
10.   
11.     public static InternalSingleton getInstance(){  
12.   
13.         return SingletonHolder.INSTANCE;  
14.   
15.     }  
16.   
17. }