• Java6种单例模式写法


    单例模式

    某个类任何情况下只有一个实例,并提供一个全局访问点来获取该实例。
    
    Java6种单例模式:2种懒汉式,2种饿汉式 ,静态内部类 ,枚举类
    
    • 1
    • 2
    • 3

    懒汉式

    synchronized+延迟加载

    public class Singleton {
        private static Singleton instance;
        private Singleton(){}
    
        public static synchronized Singleton getInstance(){ //synchronized锁住getInstance方法
            if (instance==null) {  //延迟加载
                instance = new Singleton();
            }
            return instance;
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    volatile+synchronized双检锁

    public class Singleton {
        private volatile static Singleton instance; //volatile修饰实例
        private Singleton(){}
    
        public static  Singleton getInstance(){
            if (instance==null) {
                synchronized(Singleton.class){   //synchronized锁住Singleton对象
                    if (instance==null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    饿汉式—类加载时触发实例化,避免了多线程同步问题

    类加载时初始化静态实例

    public class Singleton {
        private static Singleton instance = new Singleton(); //类加载时初始化静态实例
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
            return instance; //直接返回加载好的静态实例
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在静态代码块里初始化实例

    public class Singleton {
        private static Singleton instance = null;  
    
        static{                             
            instance = new Singleton();  //在静态代码块里初始化实例
        }
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
    
            return instance;
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    静态内部类方式—实现了延迟加载

    调用静态内部类时,在静态内部类里初始化实例

    public class Singleton {
    
        //定义静态内部类
        private static class InnerSingleton {
            private static final Singleton INSTANCE = new Singleton(); //初始化完成Singleton类静态实例
        }
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
    
            return InnerSingleton.INSTANCE; //返回静态内部类里的静态实例
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    枚举类方式–既能避免多线程同步问题,又能防止反序列化重新创建对象

    创建一个枚举,枚举成员为INSTANCE。使用枚举类.INSTANCE即可获取实例

    package acc;
    
    public enum Singleton {
    
        INSTANCE; //定义1个唯一的成员INSTANCE
    
        //枚举类里的公共方法
        public  void  doSomething() {
            System.out.println("r2323t23");
        }
    }
    
    public class TestSingleton {
        public static void main(String[] args) {
            //使用枚举类.INSTANCE即可获取实例
            Singleton.INSTANCE.doSomething();
        }
    }
    
    
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
  • 相关阅读:
    【手写系列】手把手教你如何实现 列表转树-树转列表
    多御安全浏览器chromium95内核更新:上网速度更快
    别看了,这就是你的题呀
    07 目标检测-YOLO的基本原理详解
    B站app作品列表sign
    麻了,别再为难软件测试员了
    java计算机毕业设计闲置物品线上交易系统源码+系统+数据库+lw文档+mybatis+运行部署
    ECMAScript 6 扩展
    Kubernetes(K8S) kubesphere 介绍
    WebSocket --- ws模块源码解析(详解)
  • 原文地址:https://blog.csdn.net/ThinkPet/article/details/134300603