单例设计模式

时间：2020-03-17 18:14:51 阅读：37 评论：0 收藏：0 [点我收藏+]

单例设计模式

保证一个类只有一个实例

懒汉式 (在需要的时候才实例化)

在单线程环境下实例只有一个

class SingletonTest{
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        // 都是同一个实例
        System.out.println(singleton1 == singleton2);
    }
    
}
public class Singleton {
    public static  Singleton singleton;
    // 私有化构造方法
    private Singleton(){};
    // 调用该方法的时候才实例化
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

在多线程的环境下会创建多个实例

    public static void main(String[] args) {
         new Thread(()->{ 
             Singleton instance = Singleton.getInstance();
             System.out.println(instance);
         }).start();
        new Thread(()->{
            Singleton instance = Singleton.getInstance();
            System.out.println(instance);
        }).start();
    }

技术分享图片

// 加锁
  public synchronized static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

因为在多线程并发访问 if(singleton == null) 的时候会造成线程不安全问题导致创建2个不同的实例

解决方法：

技术分享图片

如果加 synchronized 程序会有性能的损耗每次有线程访问 getInstance 方法的时候都需要进行加锁操作

优化(双重锁)：

  public  static Singleton getInstance(){
         // 如果singleton等于空的时候 是不需要加锁的
        if(singleton == null){
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }

技术分享图片

还是会创建两个不同的实例假如说第一个线程返回实例第二个线程排队等待等第一个线程释放锁的时候第二个线程还是会创建一个新的对象

  //  防止 使用到未初始化的实例和指令重排
    public volatile static  Singleton singleton;
    // 私有化构造方法
    private Singleton(){};
    // 调用该方法的时候才实例化
    public  static Singleton getInstance(){
         // 如果singleton等于空的时候 是不需要加锁的
        if(singleton == null){
            synchronized (Singleton.class){
                // 多加一次判断
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

技术分享图片

只实例化了一个对象

静态内部类实现单例

class InnerSingletonTest{
    public static void main(String[] args) {
        InnerSingleton instance1 = InnerSingleton.getInstance();
        InnerSingleton instance2 = InnerSingleton.getInstance();
        System.out.println(instance1 == instance2);
        new Thread(()->{
            InnerSingleton instance = InnerSingleton.getInstance();
            System.out.println(instance);
        }).start();
        new Thread(()->{
            InnerSingleton instance = InnerSingleton.getInstance();
            System.out.println(instance);
        }).start();
    }
}
public class InnerSingleton {
    // 需要的时候 才实例话
    private static class InnerSingletonOne{
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }
    private InnerSingleton(){
        
    }
    public static InnerSingleton getInstance(){
        return InnerSingletonOne.innerSingleton;
    }
}

技术分享图片

只有一个实例

饿汉式

class HungryTest{
    public static void main(String[] args) {
        
    }
}
public class Hungry {
    // 类初始化的时候就创建了
    private static Hungry hungry = new Hungry();
    private Hungry(){};
    public Hungry getHungry(){
        return hungry;
    }

单例设计模式

原文：https://www.cnblogs.com/chenziyue/p/12512304.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)