java中的单例设计模式详解

设计模式：对问题行之有效的解决方式，其实就是一种思想。

1.单例设计模式。

解决的问题：就是可以保证一个类在内存中的对象唯一性。
比如对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

• 如何保证对象唯一性？
  1.不允许其他程序用new创建该类对象。
  2.在该类创建一个本类实例
  3.对外提供一个方法让其他程序可以获取该对象。

• 步骤：
  1.私有化该类构造函数
  2.通过new在本类中创建一个本类对象。
  3.定义一个公有的方法，将创建的对象返回。

例如：（将下面的程序改为单例设计模式）

public class Dmo10 {
    public static void main(String[] args) {
        Test t1 = new Test();
        Test t2 = new Test();
        t1.setNum(10);
        t2.setNum(20);
        System.out.println(t1.getNum());
        System.out.println(t2.getNum());
    }
}

class Test {
    private int num;

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}
结果：
10
20

改变之后

public class Dmo10 {
    public static void main(String[] args) {
        Test t1 = Test.getInstance();
        Test t2 = Test.getInstance();
        t1.setNum(10);
        t2.setNum(20);
        System.out.println(t1.getNum());
        System.out.println(t2.getNum());
    }
}

class Test {
    private int num;

    private static Test t = new Test();
    private Test() {}

    public static Test getInstance() {
        return t;
    }
    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}
结果：
20
20

• 单例设计模式有两种方式:饿汉模式和懒汉模式

饿汉模式：类加载的时候对象就已经存在，饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变。

public class Single {

    private static Single s=new Single();
    private Single(){

    }
    public static Single getInstance(){
        return s;
    }
}

懒汉模式：类加载的时候对象还不存在，就是所谓的延迟加载方式，需要时再进行创建，懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。

public class Single {

    private static Single single = null;

    private Single() {

    }

    public static Single getInstance() {
        if (single == null) {
            single = new Single();
        }
        return single;
    }
}

以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

1、在getInstance方法上加同步

public static synchronized Single getInstance() {  
         if (single == null) {    
             single = new Single();  
         }    
        return single;  
}  

2、双重检查锁定

public static Single getInstance() {  
        if (single == null) {    
            synchronized (Single.class) {    
               if (singleton == null) {    
                  single = new Single();   
               }    
            }    
        }    
        return single;   
    }  

3、静态内部类

public class Single {    
    private static class LazyHolder {    
       private static final Single INSTANCE = new Single();    
    }    
    private Single (){}    
    public static final Single getInstance() {    
       return LazyHolder.INSTANCE;    
    }    
}    

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。