JAVA单例模式

1.单例模式的概念

java中常见创建型模式之一。

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

核心：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

优点：由于只生成一个实例，减少系统性能开销。

应用：

(1)最常见的是windows的任务管理器

(2)项目中读取配置文件的类

(3)网站中的计数器

(4)数据库的连接池的设计

..................（等等）

最常见的单例模式：

主要：

饿汉式（线程安全，调用效率高，但不可以延时加载）

懒汉式（线程安全，调用效率不高，但可以延时加载）

其他：

静态内部类式（线程安全，调用效率高，可以延时）

双重检测锁式（不稳定，不建议使用）

枚举单例（线程安全，调用效率高，但不可以延时加载）

单例实例：

public static void main(String [] args)｛
     SingletonHungry hungry1=SingletonHungry.getInstance();
     SingletonHungry hungry2=SingletonHungry.getInstance();
     System.out.println(hungry1==hungry2);//结果为true，一个类只有一个实例。
｝

2.饿汉式

public class SingletonHungry{   
   //私有构造器  
  
   private SingletonHungry() {}  
  
   //在类初始化时，立即就加载这个对象（没有延时加载优势），天然的是线程安全  
  
   private static final SingletonHungry hungry = new SingletonHungry();   
  
 //方法没有同步，调用效率高 静态工厂方法  
  public static SingletonHungry getInstance() {  
 return hungry;   
    } 
｝

3.懒汉式

    public class SingletonLazy{    
      
           //私有构造器  
           private SingletonLazy() {}    
      
          //在类初始化时，不初始化这个对象（延时加载），真正用的的时候再创建。  
      
          private static final SingletonLazy lazy;    
      
           //方法同步，调用效率低 静态工厂方法  （synchronized同步)

        public static synchronized SingletonLazy getInstance() {    
               if(lazy==null){  
                    lazy=newSingletonLazy();  
               }  
               return lazy;    
           }    
       }    

4.静态内部类式

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

只有真正调用getInstance()时,才会加载静态内部类，加载时线程式安全的，同时兼备调用高效率和延时加载。

5.双重检测锁式

    public class Singleton {    
        //私有构造器  
        private Singleton() {}    
        private static Singleton single=null;    
        public static Singleton getInstance() {    
                if (singleton == null) {      
                    synchronized (Singleton.class) {      
                       if (singleton == null) {      
                          singleton = new Singleton();     
                       }      
                    }      
                }      
                return singleton;     
            }    
    }    

由于编译优化原因和JVM底层内部模型原因，偶尔出现问题，不推荐大家使用。

6.枚举式

    public enum Singleton｛  
      //定义一个枚举元素，本身就是一个单例  
       INSTANCE;  
       //添加自己需要的操作  
       public void singletonOperation(){  
          //功能  
       }  
    ｝  

PS：

不需要延时加载时，枚举式比饿汉式好。

需要延时加载时，静态内部类式比懒汉式好。

总结不好，希望大家吐槽！！