Java设计模式之单例模式

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java设计模式之单例模式相关的知识,希望对你有一定的参考价值。

  一、前言:

  转载需要注明出处: https://i.cnblogs.com/EditPosts.aspx?opt=1

  单例模式其实很早之前就已经接触过了,但都是为了应付面试或者是为了装X。每过一段时间后,又有些模糊不清了,也仿佛从来没有项目中使用过,但最近终于有它的用武之地了。

  二、单例模式的特点:

    • 单例类只能有一个实例
    • 单例类自己给自己创建一个实例,注意是唯一的一个实例
    • 单例类必须给其他对象提供这唯一的实例

  三、单例模式分类:

    • 懒汉模式

      懒汉模式即懒加载,第一次被调用前不实例化。对于创建实例代价大,且不一定会使用时,使用懒加载模式可以减少开销

    • 饿汉模式

      饿汉模式,在类加载的同时实例化对象

  四、实现单例模式的各种方法:

    • 线程不安全的懒汉模式
public  class LazySingleton {
     private LazySingleton() {

    }
    private  static LazySingleton single;
     public  static LazySingleton getSinton(){
         if (single == null ){
            single = new LazySingleton();
        }
        return single;
    }
}

    这种方法在单线程场景中,是安全的,但在多线程情况中,单例模式未必是单例模式,也就是存在线程安全问题。

    • 同步方法下的多线程
public class LazySingleton {
    private LazySingleton() {

    }
    private static LazySingleton single;
    public static synchronized LazySingleton getSinton(){
        if(single == null){
            single = new LazySingleton();
        }
        System.out.println(Thread.currentThread().getName()+": "+single);
        return single;
    }
}

    使用sychronized修饰获取实例对象的方法,这种方法可以保证线程安全,但效率不高,每个线程都需要来获取 对象锁。

    • 同步代码块的懒汉模式
public class LazySingleton {
    private LazySingleton() {

    }

    private static LazySingleton single;

    public static LazySingleton getSinton() {
        if (single == null) {
            synchronized (LazySingleton.class) {
                single = new LazySingleton();
            }
        }
        System.out.println(Thread.currentThread().getName() + ": " + single);
        return single;
        
    }
}

    由同步方法想到同步代码块,但实际上,这种方法并不是线程安全。

    解释:两个线程A、B,A线程判断single是空的 ,当获取到锁后;B线程开始判断,发现single是空的;这时A线程又快人一步,创建了一个对象;线程B来了,获取到锁,也创建了一个对象。

    • 双重检查的懒汉  
public class LazySingleton {
    private LazySingleton() {

    }

    private static LazySingleton single;

    public static LazySingleton getSinton() {
        if (single == null) {
            synchronized (LazySingleton.class) {
                if(single== null){
                    single = new LazySingleton();
                }
            }
        }
        System.out.println(Thread.currentThread().getName() + ": " + single);
        return single;
        
    }
}

    针对同步代码块的懒汉,双重检查的懒汉可以说是最佳的,既保证了线程安全,又不需要每次都获取锁资源。(推荐双重检查懒汉)

    • 静态常量饿汉
public class HungrySingleTon {
    
    private HungrySingleTon(){
    }
    
    private final static HungrySingleTon single = new HungrySingleTon();
    
    public static HungrySingleTon getInstance(){
        return single;
    }
}

    无线程安全问题,缺点是类装在完成实例化,若一直未使用,会造成资源浪费。

    • 静态代码块饿汉模式
public class HungrySingleTon {

    private HungrySingleTon() {

    }

    private static HungrySingleTon single;

    static {
        single = new HungrySingleTon();
    }

    public static HungrySingleTon getInstance() {
        return single;
    }
}

      线程安全,与常量饿汉模式一样,若一直未被使用,会造成资源浪费。

    • 静态内部类
public class HungrySingleTon {

    private HungrySingleTon() {

    }

    public  static HungrySingleTon getInstance() {
         return InnerClass.single;
    }

    private  static  class InnerClass {
         private  static  final HungrySingleTon single = new HungrySingleTon();
    }
}

    只有调用getInstance()时才会加载静态内部类。无线程安全问题,也实现了懒加载。

 

 

  

  

 

  

  

 

以上是关于Java设计模式之单例模式的主要内容,如果未能解决你的问题,请参考以下文章

Java设计模式——创建型模式之单例模式

Java模式设计之单例模式(二)

Java设计模式之单例模式

设计模式之单例模式(Java实现)

Java之单例模式(Singleton)

设计模式之单例模式