在我们平常的开发过程中会用到很多设计模式，最近准备一一整理出来，后续会不断的更新！  先写一个最最见的的单例模式吧！

 

单例模式:控制一个类在内存中只存在一个实例。

实现步骤:

            1、私有化构造方法，使外部不能直接建立实例对象

            2、在本类内部创建私有化一个本类实例对象

            3、提供一个static方法，返回本类实例化对象，供外部直接调用

 

单例模式一般分两种:饿汉式和懒汉式

        1、饿汉式:(不管使用与否直接创建实例对象)

1. public class Singleton{
3.     //1私有化构造方法
4.     private Singleton(){
5.     }
6.    
7.     //创建本类实例对象，这里必须为static类型，可以被static方法调用
8.     private static Singleton singleton = new Singleton();
10.     //提供获取本类实例的方法，应为外部不能建立本类实例，所以写static方法可以用类名直接调用
11.     public static Singleton getSingleton(){
12.         return singleton;
13.     }
15.  }

    

        2、懒汉式（等需要使用的时候才去创建）

 

1. public class Singleton{
2.     private Singleton(){
3.     }
5.    private Static Singleton singleton = null;
6.    
8.    public static getSingleton(){
9.        if(singleton == null){
10.            singleton = new Singleton();
11.        }
12.        return Singleton;
13.   }
15. }

说明：懒汉式是线程不安全的。

 

-----

当然，单例模式深入的研究，也不止这些，还会有如何解决线程不安全问题，并且怎么保证效率比较高，这些会用到锁的概念，这些可以到网上找找别的博客看看。 

 －－－－线程安全的单列模式：（双重检查）

public class MySingleton {

    //使用volatile关键字保其可见性
    volatile private static MySingleton instance = null;

    private MySingleton(){}

    public static MySingleton getInstance() {
        try {
            if(instance != null){        //懒汉式

            }else{
                //创建实例之前可能会有一些准备性的耗时工作
                Thread.sleep(300);
                synchronized (MySingleton.class) {
                    if(instance == null){        //二次检查
                        instance = new MySingleton();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }
}