设计模式之（4）——单例模式

package cn.com.pep.model.singleton.single2;
/**
 * 
 * @Title: Singleton  
 * @Description: 线程安全的懒汉式 
 * @author wwh 
 * @date 2022-8-24 15:07:07
 */
public class Singleton {
    
    /**
     * 是否是懒加载：是
     * 是否线程安全：是
     * 实现难度：容易
     * 描述：这种方式具备很好的lazy loading，能够在多线程中很好的工作，但是效率比较低，99%情况下不需要同步；
     * 优点：第一次调用才初始化，避免了内存的浪费；
     * 缺点：必须加锁synchronized才能保证单例，在静态方法上加的是类锁会影响效率；
     */
    
    private static Singleton instance;
    
    private Singleton() {
        // TODO Auto-generated constructor stub
    }
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        
        return instance;
    }

}

package cn.com.pep.model.singleton.single3;

/**
 * 
 * @Title: Singleton
 * @Description:饿汉式单例
 * @author wwh
 * @date 2022-8-24 15:45:01
 */
public class Singleton {
    /**
     * 是否是懒加载：否
     * 是否线程安全：是
     * 实现难度：容易
     * 描述：比较常用，但是容易产生垃圾对象；
     * 优点：没有加锁，执行效率会提高；
     * 缺点：类加载时候就会初始化，浪费内存；
     * 它基于classloader机制避免了多线程同步的问题，不过，instance在类装载的时候就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance，
     * 但也不确定有其他方式导致类加载，这时候就没有达到懒加载的效果；
     */
    
    private static Singleton instance = new Singleton();

    private Singleton() {
        // TODO Auto-generated constructor stub
    }

    public static Singleton getInstance() {
        return instance;
    }
package cn.com.pep.model.singleton.single4;

/**
 * 
 * @Title: Singleton
 * @Description:双重校验锁
 * @author wwh
 * @date 2022-8-24 16:02:19
 */
public class Singleton {
    
    /**
     * 是否是懒加载：是
     * 是否多线程安全：是
     * 实现难度：较复杂
     * 描述：这种方式采用锁双锁机制，安全且在多线程情况下能保持高性能；
     */
    // volatile关键字在这使用时，是利用其禁止虚拟机的指令重排特点，防止返回一个未被完整初始化的对象；
    private volatile static Singleton instance;

    private Singleton() {
        // TODO Auto-generated constructor stub
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
　　　　　　　　　　//假如当前有两个线程同时执行获取实例的方法，cpu执行A线程执行到这个地方说明instance==null这个条件成立,此时发生了线程切换，当前线程释放了类锁，此时
　　　　　　　　　　//cpu执行B线程，执行完之后instance!=null,然后又切换回A线程执行，如果不instance== null做判断会再将instace初始化一次,可能会引起其他未知的错误。
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

package cn.com.pep.model.singleton.single5;

/**
 * @Title: Singleton
 * @Description: 静态内部类
 * @author wwh
 * @date 2022-8-24 16:12:51
 */
public class Singleton {
    
    /**
     * 是否是懒加载：是
     * 是否是多线程安全：是
     * 实现难度：一般
     * 描述：这种方式能达到和双检锁方式一样的功效，实现更简单；
     * 这种方式同样利用了classloader机制来保证实例初始化的时候只有一个线程，它跟饿汉式不同的是：
     * 第三种方式，只要Sington类被加载了，那么instance实例就会被初始化，没有达到懒加载的效果，
     * 而这种方式即使Singleton类被加载了，但是SingletonHolder类没有被主动使用，只有通过显示调用
     * getInstance()方法时候，才会显示加载SingletonHolder类，从而实例化instance对象；
     */

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
        // TODO Auto-generated constructor stub
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

}

package cn.com.pep.model.singleton.single6;

import java.io.Serializable;

/**
 * 
 * @Title: Singleton
 * @Description:
 * @author wwh
 * @date 2022-8-24 16:49:19
 */
public enum Singleton implements Serializable{

    SPRING{

        @Override
        public void say(String message) {
            System.err.println(message);
        }
        
    };
    
    public abstract void say(String message);
}

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
package cn.com.pep.model.singleton.single6;

import java.io.PrintStream;
import java.io.Serializable;

public abstract class Singleton extends Enum implements Serializable {

    public static final Singleton SPRING;
    private static final Singleton ENUM$VALUES[];

    private Singleton(String s, int i) {
        super(s, i);
    }

    public abstract void say(String s);

    public static Singleton[] values() {
        Singleton asingleton[];
        int i;
        Singleton asingleton1[];
        System.arraycopy(asingleton = ENUM$VALUES, 0, asingleton1 = new Singleton[i = asingleton.length], 0, i);
        return asingleton1;
    }

    public static Singleton valueOf(String s) {
        return (Singleton) Enum.valueOf(cn / com / pep / model / singleton / single6 / Singleton, s);
    }

    Singleton(String s, int i, Singleton singleton) {
        this(s, i);
    }

    static {
        SPRING = new Singleton("SPRING", 0) {

            public void say(String message) {
                System.err.println(message);
            }

        };
        ENUM$VALUES = (new Singleton[]{SPRING});
    }
}

/*    */ // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
/*    */ package cn.com.pep.model.singleton.single6;
/*    */ 
/*    */ import java.io.PrintStream;
/*    */ 
/*    */ 
/*    */ 
/*    */ 
/*    */ class Singleton$1 extends Singleton
/*    */ {
/*    */ 
/*    */     Singleton$1(String s, int i)
/*    */     {
/* 14 */         super(s, i, null);
/*    */     }
/*    */     public void say(String message)
/*    */     {
/* 18 */         System.err.println(message);
/*    */     }
/*    */ }