单例模式的深刻理解及最优法例子

 懂的越多，发现所知越少。是时候丰富下基础知识了，以下也是网上归纳总结的知识点。主要归纳几点

第一：单例模式概念；第二：单例模式的特点及核心知识；第三：最优法单例模式例子；第四：使用单例和不使用单例模式 到底有什么区别（代码举例）

一、单例模式的概念：指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。（百度）

二、单例模式的特点：

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

  单例模式shou的核心知识：

 (1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

 (2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

 (3) 定义一个静态方法返回该类的实例。

三、单例模式最优方案例子

package com.test.api;

/**  
 * 方法四
 * 单例模式最优方案
 * 线程安全  并且效率高  
 *  
 */  
public class SingletonTest { 
	// 定义一个私有构造方法
    private SingletonTest() { 
     
    }   
    //定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用)
    private static volatile SingletonTest instance;  

    //定义一个共有的静态方法，返回该类型实例
    public static SingletonTest getIstance(String str) { 
        // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率）
        if (instance == null) {
            //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (SingletonTest.class) {
                //未初始化，则初始instance变量
                if (instance == null) {
                    instance = new SingletonTest();   
                }   
            }   
        }   
        return instance;   
    }   
}

四、使用单例和不使用单例模式 到底有什么区别（代码举例）

=======================首先，先看看平常我们写的代码（不使用单例模式）

实体类：

public class NotSingletonTest {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public void Test(){
		System.out.println("this is "+name);
	}

}

测试类：

public static void main(String[] args) {

		NotSingletonTest not1 = new NotSingletonTest();
		NotSingletonTest not2 =  new NotSingletonTest();;
		not1.setName("1");
		not2.setName("2");

		not1.Test();
		not2.Test();

		if(not1==not2){
			System.out.println("same instance2");
		}else if(not1 != not2){
			System.out.println("different instance2");
		}
	}

最后输出的是  ：

this is 1
this is 2

different instance2

===============然后，我们再看使用单例模式会有什么效果
实体类：

package com.test.api;

/**  
 * 方法四
 * 单例模式最优方案
 * 线程安全  并且效率高  
 *  
 */  
public class SingletonTest { 
 private String name;
 
    public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
	// 定义一个私有构造方法
    private SingletonTest() { 
     
    }   
    //定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用)
    private static volatile SingletonTest instance;  

    //定义一个共有的静态方法，返回该类型实例
    public static SingletonTest getIstance(String str) { 
        // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率）
        if (instance == null) {
            //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (SingletonTest.class) {
                //未初始化，则初始instance变量
                if (instance == null) {
                    instance = new SingletonTest();   
                }   
            }   
        }   
        return instance;   
    }   
    public  void Test(){
    	System.out.println("this is "+name);
    } 
}

测试类：

public static void main(String[] args) {

		SingletonTest sin1 = SingletonTest.getIstance("1");
		SingletonTest sin2 = SingletonTest.getIstance("2");

		sin1.setName("1");
		sin2.setName("2");

		sin1.Test();
		sin2.Test();

		if(sin1==sin2){
			System.out.println("same instance1");
		}else if(sin1 != sin2){
			System.out.println("different instance1");
		}

	}

最后输出的是：

this is 2
this is 2
same instance1

 总结： 看出来了吧，使用了单例模式，顾名思义保证调用这个类的时候，只实例化一次。因此输出的都是this is 2

参考原文：

http://blog.sina.com.cn/s/blog_8af106960101ctlq.html

http://www.cnblogs.com/yinxiaoqiexuxing/p/5605338.html