java设计模式之单例模式

单例模式

单例模式顾名思义就是 只有一个实例的模式。
有以下特点：　　
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
以下给出5种单例模式：
饿汉模式

public class Single{
    private final static Single getInstance=new Single();          //创建一个本类的实例 且私有静态化
    private Single(){}                                           //防止其他类new实例 私有化构造函数
    public static Single newInstance(){              //公开一个静态方法给其他类调用
              return getInstance                             
     }
}

饿汉模式的缺点是：当这个类被加载的时候就会实例化一个对象出来，比较浪费资源 降低类内存的使用率。
没有实现lazy loading。

升级版饿汉模式(建议使用)
这个版本能够有效的避免资源浪费 内存达到合理的一个运用。

public class Single{
	private Single(){}                                           //还是需要防止其他类new实例 所以私有化构造函数
	private  static class  innerSingle{                                 //接下来我们建一个inner class
	private final static Single getInstance=new Single();          //在inner class 我们创建一个本类的实例 也将他私有静态化
        
        }      
    public static Single newInstance(){              //公开一个静态方法给其他类调用
              return innerSingle.vetInstance                             
     }                                                      
}

懒汉模式(仅限单线程)

public class Singleton {
    private static Singleton instance=null;   //先声明个静态变量
    private Singleton(){                                //还是需要防止其他类new实例 所以私有化构造函数
        
    }
    public static Singleton getInstance(){                
        if(instance==null){                            //这里我们判断下instance是否为空在进行实例化 
            instance=new Singleton();
        }
        return instance;
    }
}

这样一来确实不存在浪费内存的问题。 但是当多个线程同时执行的时候就会出现创建多个实例。

升级版懒汉模式

public class Singleton {
    private static Singleton instance=null;
    private Singleton(){
        
    }
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

加上了同步锁，使得在多线程的情况下可以用。例如：当两个线程同时想创建实例，由于在一个时刻只有一个线程能得到同步锁，当第一个线程加上锁以后，第二个线程只能等待。第一个线程发现实例没有创建，创建之。第一个线程释放同步锁，第二个线程才可以加上同步锁，执行下面的代码。由于第一个线程已经创建了实例，所以第二个线程不需要创建实例。保证在多线程的环境下也只有一个实例。
缺点：每次通过getInstance方法得到singleton实例的时候都有一个试图去获取同步锁的过程。而众所周知，加锁是很耗时的。能避免则避免。

没必要版懒汉模式

public class Singleton {
    private static Singleton instance=null;
    private Singleton(){
        
    }
    public static Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
                if(instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

注解：只有当instance为null时，需要获取同步锁，创建一次实例。当实例被创建，则无需试图加锁。
缺点：用双重if判断，复杂，容易出错。