java设计模式--单例

GOF23(group of four)---由4个大牛总结的JAVA23种常用的设计模式，归根结底都是为了代码的可扩展性。

设计模式中一种比较重要的思想就是：开闭原则，尽量做到对扩展开放，对修改关闭。

单例模式：开发中最常见也是最简单的一种模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。

1.懒汉式单例

//懒汉式单例类.在第一次调用的时候实例化自己，优点：延时加载，用到时候才NEW，缺点：方法是同步的，多线程调用时，需要等待锁，所以效率低

public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static synchronized  Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}  

懒汉式单例双重检查

public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if(single == null){
            synchronized(Singleton.class){
               if (single == null) { 
                   single = new Singleton(); 
               } 
            }
         } 
        return single;  
    }  
}  

2.恶汉式单例 ---初始化时就创建对象，优点：执行效率高，缺点：一开始就创建对象，比较浪费

//饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
} 

3.静态内部类模式  比以上都要好  

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

4.枚举单例   不会被反序列化，或反编译，执行效率也比较高

public enum MeijuDl {
    //本身就是单例的
    INSTATCE;
    public void fangfa(){
    }
    
    public static void main(String[] args) {
        MeijuDl.INSTATCE.fangfa();
    }

}

以上几种方法都是线程安全的

测试方法

public class TestXiaolv {
    
    public static void main(String[] args) throws InterruptedException {
        
        //线程计数器
        final CountDownLatch countDownLatch = new CountDownLatch(10);
        long t1 = System.currentTimeMillis();
        
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 100000; i++) {
                        Object o = LanhanDL.getInstance();
                    }
                    countDownLatch.countDown();
                    
                }
            }).start();
        }
        
        countDownLatch.await();
        
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
        
        
    }
}