单例设计模式之总结

• 单例模式：保证类只有一个实例，不能使用new来创建一个对象，而是提供了一个访问他的全局的访问点getInstance
• 优点：节省系统资源，其中的构造函数为私有
• 使用在：要求产生唯一序列号，数据库连接，spring框架

public class SingleTon{
    private static final SingleTon INSTANCE = new SingleTon();
    public static SingleTon getInstance(){
        return INSTANCE;
    }
    private SingleTon(){

    }
    public void m(){
        System.out.println("m");
    }
    public static void main(String[] args) {
        SingleTon instance = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance==instance2);
    }
}

/**
 * 静态代码块
 */
class SinlgeTon2{
    private final static SinlgeTon2 INSTANCE;
    static {
        INSTANCE = new SinlgeTon2();
    }
    private SinlgeTon2(){

    }

    public static SinlgeTon2 getInstance(){
        return INSTANCE;
    }
    public void m(){
        System.out.println("singleton2");
    }
}

/**
 * 懒加载模式会导致线程不安全
 */
class SingleTon3{
    private static SingleTon3 INSTANCE;
    private SingleTon3(){

    }
    public static SingleTon3 getINSTANCE(){
        if (INSTANCE==null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new SingleTon3();
        }
        return INSTANCE;
    }
    public static void main(String[] args) {
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                System.out.println(SingleTon3.getINSTANCE().hashCode());
            }).start();
        }
    }
}

/**
 * 同步方法来保证线程安全，那扩展思路使用同步代码块保证线程安全
 */
class SingleTon4{
    private static SingleTon4 INSTANCE;
    private SingleTon4(){

    }

    synchronized public static  SingleTon4 getINSTANCE(){
        if (INSTANCE==null){
            INSTANCE = new SingleTon4();
        }
        return INSTANCE;
    }
    public static void main(String[] args) {
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                System.out.println(SingleTon4.getINSTANCE().hashCode());
            }).start();
        }
    }
}

/**
 * 造成线程不安全
 */

class SingleTon5{
    private static SingleTon5 INSTANCE;
    private SingleTon5(){

    }
    public static SingleTon5 getINSTANCE(){
        if (INSTANCE == null){
            synchronized (SingleTon5.class){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new SingleTon5();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(SingleTon5.getINSTANCE().hashCode());
                }
            }
        }).start();
    }
}

/**
 * 线程安全
 */
class SingleTon6{
    private static SingleTon6 INSTANCE;

    private SingleTon6(){}

    public static SingleTon6 getINSTANCE(){
        if (INSTANCE==null){

            synchronized (SingleTon6.class){
                if (INSTANCE==null){
                    INSTANCE = new SingleTon6();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(SingleTon6.getINSTANCE().hashCode());
                }
            }
        }).start();
    }
}

/**
 * 枚举类型完成单例模式书写
 */
enum SingleTon7{
    INSTANCE;

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(SingleTon7.INSTANCE.hashCode());
                }
            }
        }).start();
    }
}

/**
 * 静态内部类
 */

class SingleTon8{
    private static SingleTon8 INSTANCE;

    static class Inner{
        private static final SingleTon8 INSTANCE = new SingleTon8();
    }
    public static SingleTon8 getInstance(){
        return Inner.INSTANCE;
    }
    private SingleTon8(){
    }
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(SingleTon8.getInstance().hashCode());
                }
            }
        }).start();
    }
}