单例模式

单例模式

本文主要介绍单例模式的简单实现和功能

单例模式功能：

用来保证类在运行期间只会创建一个类实例，另外单例模式还提供唯一访问这个类实例的访问点，就是那个getInstance()方法。

不管采用哪种实现，都是只关心类实例的创建问题，并不关心具体的业务功能。

---

单例模式的特点:

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

单例模式主要分为：懒汉式，饿汉式

---

饿汉式的实现：

/*
 * 饿汉式单例实现类
 */
public class Singleton {

    //定义一个变量创建好的类实例，直接在这里创建类实例，只创建一次
    private static Singleton uniqueInstance = new Singleton();

    //私有化构造方法，好在内部控制创建实例的数目
    private Singleton(){
        System.out.println("单例类初始化");
    }
    /*
     * 定义方法来为客户端提供类的实例
     * @param:Singleton实例
     */
    public static Singleton getInstance(){
        return uniqueInstance;
    }



    public static void main(String[] args){
        Singleton singleton = Singleton.getInstance();

    }   
}

讲解：
饿汉式也是一种比较形象的称谓。既然饿，那么在创建对象实例的时候就比较着急，饿了嘛，于是在装载类的时候就创建对象实例。饿汉式是典型的 空间换时间 ，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

1.私有化构造方法：

想要在运行期间控制某一个类的实例只有一个，那么首先任务就是控制创建实例的地方，即不能随便创建实例。

private Singleton(){

}

通过私有化构造方法达到只能内部创建实例。

2.提供获取实例的方法：

构造方法被私有化,外部创建不了类实例就没有办法调用这个对象的方法。
单例模式让类提供一个方法来返回类实例，便于在外面使用。

获取对象实例的方法要通过客户端调用，而这个调用大多建立在得到类实例的基础上，那么有些自相矛盾了。

注意： 解决方法则是：在方法上加上static，就可以直接通过类来调用方法。

public static Singleton singleton(){
}

---

懒汉式实例：

/*
 * 懒汉式单例实现类
 */
public class Singleton {

    //定义一个变量创建好的类实例，直接在这里创建类实例，只创建一次
    private static Singleton uniqueInstance = null;

    //私有化构造方法，好在内部控制创建实例的数目
    private Singleton(){

    }
    /*
     * 定义方法来为客户端提供类的实例
     * @param:Singleton实例
     */
    public static Singleton getInstance(){
        if(uniqueInstance == null){
            uniqueInstance = new Singleton();
        }

        return uniqueInstance;
    }
}

讲解：

懒汉式其实是一种比较形象的称谓。既然懒，那么在创建对象实例的时候就不着急。会一直等到马上要使用对象实例的时候才会创建，懒人嘛，总是推脱不开的时候才会真正去执行工作，因此在装载对象的时候不创建对象实例。懒汉式是典型的 时间换空间，就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。

与前面的私有化构造方法，提供静态getInstance()
来提供实例一样。差别在如何实现getInstance()。

利用static特性：
1.static变量在类装载时进行初始化
2.多个实例的static变量会共享同一块内存区域

即static变量值初始化一次，就是在类装载时，而且多个实例会共享一块内存空间。

单例模式存在的问题：

懒汉式单例的代码是线程不安全的。为了线程安全，可以采用以下方法：

1.synchronized同步

    public static synchronized Singleton getInstance(){
        if(uniqueInstance == null){
            uniqueInstance = new Singleton();
        }

        return uniqueInstance;
    }

单例模式应用场景：

单例模式应用的场景一般发现在以下条件下：

（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如日志文件，应用配置。

（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

现在我就从懒汉式说下 缓存 的基本实现原理：

1.定义一个存放缓存数据的容器

2.从缓存中获取数据的做法：

首先，从缓存里获取值
接着，判断缓存里是否有值
最后，如果有值，直接使用。如果没有，则去取相应的值。
接着把获取的值回到缓存【容器】。

import java.util.HashMap;
import java.util.Map;
/*
 * Java中缓存的基本实例
 */
public class JavaCache {

    /*
     * 缓存数据的容器，定义成Map或者是方便访问，直接根据Key或者可以获取value
     * key选用String是为了简单，方便演示
     */
    private Map<String, Object> map = new HashMap<>();

    /*
     * 从缓存中获取值
     * @param:key,设置key值
     * @return:key对应的value值
     */
    public Object getValue(String key){

        //先从缓存中取值
        Object obj = map.get(key);
        //判断缓存里面是否有值
        if(obj == null){
            //如果没有，就去获取相应的数据，比如读取到数据库或者文件
            //这里只是演示，直接写假数据
            obj = key + ",value";
            //把获取的值回到缓存中
            map.put(key,obj);
        }
        //有值则直接使用
        return obj;
    }
}

import java.util.HashMap;
import java.util.Map;

//使用缓存来模拟实现单例
public class Singleton {

    //定义一个缺省的key值，用来标识在缓存的存放
    private final static String DEFAULT_KEY="One";

    //缓存实例的容器
    private static Map<String,Singleton> map = new HashMap();
    //私有化构造方法，好在内部控制创建实例的数目
    private Singleton(){

    }
    /*
     * 定义方法来为客户端提供类的实例
     * @param:Singleton实例
     */
    public static Singleton getInstance(){

        Singleton instance = map.get(DEFAULT_KEY);
        if(instance == null){
            instance = new Singleton();
            map.put(DEFAULT_KEY,instance);
        }
        return instance;
    }

    public static void main(String[] args){
        for(int i=0;i<5;i++){
            System.out.println(Singleton.getInstance());
        }
    }

}

---

有什么不对的地方还请各位大侠多多关照，狠狠地批评指正撒。。