精华内容
下载资源
问答
  • Java单例模式代码实现
    2020-12-25 08:58:45

    双检查锁机制(Double Check Locking)实现

    在声明变量时使用了 volatile 关键字来保证其线程间的可见性;在同步代码块中使用二次检查,以保证其不被重复实例化
    同时在调用getInstance()方法时不进行同步锁,效率高。这种实现方式既保证了其高效性,也保证了其线程安全性。

    public class Singleton {
        public volatile static Singleton instance=null;//volatile保证变量可见性
        private Singleton(){} //私有化构造方法
        public static Singleton getSingleton(){
            if(instance==null){
                synchronized(Singleton.class){
                    if(instance==null)//二次检查
                        instance=new Singleton();
                    else
                        return instance;
                }
            }
            return instance;
        }
    }
    
    
    更多相关内容
  • java单例模式实例

    2018-07-17 18:51:20
    一个简单的java工程,包含注释,一目了然,其中包含了单例模式的所有实现方式,懒汉式,饿汉式,双重校验,枚举,静态内部类等方式实现单例。
  • JAVA单例模式代码实现

    2020-08-26 00:05:25
    JAVA常见的设计模式之单例模式 懒汉模式 懒汉式是典型的时间换空间,也就是每次获取实例都会进行判断,看是否需要创建实例,浪费判断的时间。当然,如果一直没有人使用的话,那就不会创建实例,则节约内存空间...

    JAVA常见的设计模式之单例模式

    • 懒汉模式

                 懒汉式是典型的时间换空间,也就是每次获取实例都会进行判断,看是否需要创建实例,浪费判断的时间。当然,如果一直没有人使用的话,那就不会创建实例,则节约内存空间(搬运工)。

    标准的懒汉模式

    class LazySingleton {
        // 私有成员属性
        private LazySingleton lazySingleton;
        
        // 私有构造方法
        private LazySingleton() {
        }
        
        // 公共的获取实例方法
        public LazySingleton getLazySingleton() {
            // 如果成员属性为空,则创建实例
            if (lazySingleton == null) {
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    }

    单线程环境下,该单例模式只会有一个实例

    public class TestDemo
    {
        public static void main(String[] args) {
            LazySingleton lazySingleton = LazySingleton.getLazySingleton();
            LazySingleton lazySingleton2 = LazySingleton.getLazySingleton();
            System.out.println(lazySingleton == lazySingleton2);
        }
    }

    运行结果:

    多线程模式下,可能会产生多个实例

    public class TestDemo
    {
        public static void main(String[] args) {
            new Thread(() -> {
                LazySingleton lazySingleton = LazySingleton.getLazySingleton();
                System.out.println(lazySingleton);
            }).start();
            new Thread(() -> {
                LazySingleton lazySingleton = LazySingleton.getLazySingleton();
                System.out.println(lazySingleton);
            }).start();
        }
    }

    运行结果:

    初步改进

    class LazySingleton {
        // 私有成员属性
        private static LazySingleton lazySingleton;
    
        // 私有构造方法
        private LazySingleton() {
        }
    
        // 公共的获取实例方法
        public synchronized static LazySingleton getLazySingleton() {
            // 如果成员属性为空,则创建实例
            if (lazySingleton == null) {
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    }

    缺点,每次调用方法都会加锁,效率低

    再次改进

    class LazySingleton {
        // 私有成员属性,使用volatile可以保证代码的有序性,防止指令重排
        private volatile static LazySingleton lazySingleton;
    
        // 私有构造方法
        private LazySingleton() {
        }
    
        // 公共的获取实例方法
        // 使用synchronized + 双重确认机制可以保证线程安全,但有可能存在指令重排,会导致创建多个实例
        public static LazySingleton getLazySingleton() {
            if (lazySingleton == null) {
                synchronized (LazySingleton.class) {
                    if (lazySingleton == null) {
                        lazySingleton = new LazySingleton();
                    }
                }
            }
            return lazySingleton;
        }
    }

    静态类部类单例

    /**
     * 由静态内部类持有单例对象,并调用外部类的私有构造器初始化,由外部类调用静态内部类的属性
     * 本质是一个懒汉模式,在类加载时才会初始化对象
     */
    class InnerSingleton implements Serializable {
    
        private static class InnerSingletonHolder {
            private static InnerSingleton innerSingleton = new InnerSingleton();
        }
    
        private InnerSingleton() {
        }
    
        public static InnerSingleton getInnerSingleton() {
            return InnerSingletonHolder.innerSingleton;
        }
    
    }

     静态类不类单例不会有线程安全问题,线程安全由类加载机制担保

    恶汉模式

                 饿汉式是典型的空间换时间,当类装载的时候就会创建类实例,不管你用不用,先创建出来,然后每次调用的时候,就不需要再判断了,节省了运行时间(搬运工)。 

    // 利用类加载机制保证线程安全
    class HungrySingleton {
        private static HungrySingleton hungrySingleton = new HungrySingleton();
    
        private HungrySingleton() {
        }
    
        public static HungrySingleton getHungrySingleton() {
            return hungrySingleton;
        }
    }

     枚举单例模式

    package com.hy.test.singletonDemo;
    
    public enum EnumSingletonDemo {
        INSTANCE;
    
    }
    
    class EnumTest {
        public static void main(String[] args) {
            EnumSingletonDemo instance = EnumSingletonDemo.INSTANCE;
            EnumSingletonDemo instance2 = EnumSingletonDemo.INSTANCE;
            System.out.println(instance == instance2);
        }
    }
    

    运行结果:

    单例模式可能出现的问题(都会用静态类不类单例举例)

    反射攻击

    /**
     * 测试demo
     *
     * @auther Hy
     * @date 2020/8/25
     */
    public class TestDemo {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
            Class clazz = InnerSingleton.class;
            Constructor<InnerSingleton> declaredConstructor = clazz.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            InnerSingleton innerSingleton1 = (InnerSingleton) declaredConstructor.newInstance();
            System.out.println(innerSingleton == innerSingleton1);
        }
    }
    
    /**
     * 由静态内部类持有单例对象,并调用外部类的私有构造器初始化,由外部类调用静态内部类的属性
     * 本质是一个懒汉模式,在类加载时才会初始化对象
     */
    class InnerSingleton implements Serializable {
    
        private static class InnerSingletonHolder {
            private static InnerSingleton innerSingleton = new InnerSingleton();
        }
    
        private InnerSingleton() {
        }
    
        public static InnerSingleton getInnerSingleton() {
            return InnerSingletonHolder.innerSingleton;
        }
    
    }

    运行结果:

    由此可见,反射生成了一个新的对象,不符合单例模式的定义

    解决方法:在私有构造器中添加判断,如果已存在实例对象,抛出异常(也可进行其他操作,根据需求决定)

    优化后的代码如下

    /**
     * 测试demo
     *
     * @auther Hy
     * @date 2020/8/25
     */
    public class TestDemo {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
            Class clazz = InnerSingleton.class;
            Constructor<InnerSingleton> declaredConstructor = clazz.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            InnerSingleton innerSingleton1 = (InnerSingleton) declaredConstructor.newInstance();
            System.out.println(innerSingleton == innerSingleton1);
        }
    }
    
    /**
     * 由静态内部类持有单例对象,并调用外部类的私有构造器初始化,由外部类调用静态内部类的属性
     * 本质是一个懒汉模式,在类加载时才会初始化对象
     */
    class InnerSingleton implements Serializable {
    
        private static class InnerSingletonHolder {
            private static InnerSingleton innerSingleton = new InnerSingleton();
        }
    
        private InnerSingleton() {
            // 防止反射攻击,只有恶汉与静态类部类能防止反射攻击
            if (InnerSingletonHolder.innerSingleton != null) {
                throw new RuntimeException("单例模式已存在一个实例");
            }
        }
    
        public static InnerSingleton getInnerSingleton() {
            return InnerSingletonHolder.innerSingleton;
        }
    
    }

     运行结果:

    注意:只有恶汉模式与静态类部类能防止反射攻击

    序列化相关问题

     首先,我们对创建的实例进行序列化,代码如下:

    /**
     * 测试demo
     *
     * @auther Hy
     * @date 2020/8/25
     */
    public class TestDemo {
        public static void main(String[] args) throws IOException {
            InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
            // 序列化测试
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("innerTest"));
            oos.writeObject(innerSingleton);
            oos.close();
            // 反序列化
    /*        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("innerTest"));
            InnerSingleton innerSingleton1 = (InnerSingleton) ois.readObject();
            System.out.println(innerSingleton == innerSingleton1);*/
        }
    }
    
    /**
     * 由静态内部类持有单例对象,并调用外部类的私有构造器初始化,由外部类调用静态内部类的属性
     * 本质是一个懒汉模式,在类加载时才会初始化对象
     */
    class InnerSingleton implements Serializable {
    
        // 需要固定序列化版本号id,如果不固定,JVM会根据字段、方法等生成一个序列化ID,并存入对应的序列化文件,反序列化时,
        // 会按照相同规则生成一个序列化版本号进行对比,如果类已经发生了改变,反序列化的版本号会对应不上,反序列化会失败
        private static final long serialVersionUID = 7822769557659839582L;
    
        private static class InnerSingletonHolder {
            private static InnerSingleton innerSingleton = new InnerSingleton();
        }
    
        private InnerSingleton() {
            // 防止反射攻击,只有恶汉与静态类不类能防止反射攻击
            if (InnerSingletonHolder.innerSingleton != null) {
                throw new RuntimeException("单例已存在一个实例");
            }
        }
    
        public static InnerSingleton getInnerSingleton() {
            return InnerSingletonHolder.innerSingleton;
        }
        
    }

    然后,我们进行反序列化,查看反序列化生成的实例跟单例的实例是否是同一个

    /**
     * 测试demo
     *
     * @auther Hy
     * @date 2020/8/25
     */
    public class TestDemo {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
            // 序列化测试
    /*        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("innerTest"));
            oos.writeObject(innerSingleton);
            oos.close();*/
            // 反序列化
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("innerTest"));
            InnerSingleton innerSingleton1 = (InnerSingleton) ois.readObject();
            System.out.println(innerSingleton == innerSingleton1);
        }
    }
    
    /**
     * 由静态内部类持有单例对象,并调用外部类的私有构造器初始化,由外部类调用静态内部类的属性
     * 本质是一个懒汉模式,在类加载时才会初始化对象
     */
    class InnerSingleton implements Serializable {
    
        // 需要固定序列化版本号id,如果不固定,JVM会根据字段、方法等生成一个序列化ID,并存入对应的序列化文件,反序列化时,
        // 会按照相同规则生成一个序列化版本号进行对比,如果类已经发生了改变,反序列化的版本号会对应不上,反序列化会失败
        private static final long serialVersionUID = 7822769557659839582L;
    
        private static class InnerSingletonHolder {
            private static InnerSingleton innerSingleton = new InnerSingleton();
        }
    
        private InnerSingleton() {
            // 防止反射攻击,只有恶汉与静态类不类能防止反射攻击
            if (InnerSingletonHolder.innerSingleton != null) {
                throw new RuntimeException("单例已存在一个实例");
            }
        }
    
        public static InnerSingleton getInnerSingleton() {
            return InnerSingletonHolder.innerSingleton;
        }
    
    }

    运行结果:

    由此可见,反序列化创建了一个新的实例

    解决方法:Serializable的源码中给出了提示

    /**
     * 测试demo
     *
     * @auther Hy
     * @date 2020/8/25
     */
    public class TestDemo {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
            // 序列化测试
    /*        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("innerTest"));
            oos.writeObject(innerSingleton);
            oos.close();*/
            // 反序列化
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("innerTest"));
            InnerSingleton innerSingleton1 = (InnerSingleton) ois.readObject();
            System.out.println(innerSingleton == innerSingleton1);
        }
    }
    
    /**
     * 由静态内部类持有单例对象,并调用外部类的私有构造器初始化,由外部类调用静态内部类的属性
     * 本质是一个懒汉模式,在类加载时才会初始化对象
     */
    class InnerSingleton implements Serializable {
    
        // 需要固定序列化版本号id,如果不固定,JVM会根据字段、方法等生成一个序列化ID,并存入对应的序列化文件,反序列化时,
        // 会按照相同规则生成一个序列化版本号进行对比,如果类已经发生了改变,反序列化的版本号会对应不上,反序列化会失败
        private static final long serialVersionUID = 7822769557659839582L;
    
        private static class InnerSingletonHolder {
            private static InnerSingleton innerSingleton = new InnerSingleton();
        }
    
        private InnerSingleton() {
            // 防止反射攻击,只有恶汉与静态类不类能防止反射攻击
            if (InnerSingletonHolder.innerSingleton != null) {
                throw new RuntimeException("单例已存在一个实例");
            }
        }
    
        public static InnerSingleton getInnerSingleton() {
            return InnerSingletonHolder.innerSingleton;
        }
    
        // 反序列化时,如果是单例模式,需要重写该方法,返回单例的实例,否则会获取到不同的对象
        Object readResolve() throws ObjectStreamException {
            return InnerSingletonHolder.innerSingleton;
        }
    }

    运行结果:

    因此,在工作中推荐大家使用静态类部类单例模式,可以有效的防止反射攻击与序列化带来的相关问题

    展开全文
  • java单例模式代码

    千次阅读 2014-10-08 15:33:13
    单例模式,在程序运行期间只有一个实例存在。 简单单例模式

    单例模式,在程序运行期间只有一个实例存在。

    简单饿汉式单例模式实现代码如下:


    package com.demo;
    
    public class Singleton {
    	private Singleton() {
    	}
    
    	public static Singleton instance = new Singleton();
    
    	public static Singleton getInstance() {
    		return instance;
    	}
    
    }

    空间换时间。


    简单懒汉式单例模式代码:

    package com.demo;
    
    public class Singleton {
    	private Singleton() {
    	}
    
    	public static Singleton instance;
    
    	public static Singleton getInstance() {
    		if (instance == null) {
    			instance = new Singleton();
    		}
    		return instance;
    	}
    
    }
    

    时间换空间。

    简单的单例模式在多线程中容易出现问题,获取到的instance并非同一个对象。


    同步方法实现单例模式:

    package com.demo;
    
    public class Singleton {
    	private Singleton() {
    	}
    
    	public static Singleton instance;
    
    	public static synchronized Singleton getInstance() {
    		if (instance == null) {
    			instance = new Singleton();
    		}
    		return instance;
    	}
    
    }
    
    同步方法实现单例模式,效率低下,每一线程进入,都将阻塞其它线程的访问。


    双重检查加锁实现单例模式:

    package com.demo;
    
    public class Singleton {
    	private Singleton() {
    	}
    
    	public static Singleton instance;
    
    	public static Singleton getInstance() {
    		if (instance == null) {
    			synchronized (Singleton.class) {
    				if(instance == null){
    					instance = new Singleton();
    				}
    			}
    		}
    		return instance;
    	}
    
    }
    
    双重检查加锁(Double Checked Locking)很巧妙实现了单例模式,步骤为:

    1、检查变量是否初始化(不加锁),如果已经初始化,立即返回变量。

    2、获得锁。

    3、再次检查变量是否初始化,如果变量已经被之前的某个线程初始化,立即返回此变量。

    4、否则的话初始化变量并返回。

    遗憾的是,传统的双重检查在java中并不可靠,双重检查锁定的理论是完美的,不幸的是,现实完全不同,java并不能保证它在单处理器或者多处理器计算机上顺利运行。

    java平台的内存模型允许“无序写入”,instance的赋值和初始化的顺序是不确定的,在new 一个对象之前instance的值就已经不为null了,所以如果此时有线程执行到if(instance==null)的条件判断的时候就已经返回了一个不为null却未被初始化的instance。

    解决方案:1、可以采用“饿汉式”解决,多线程下jvm可以保证类中静态内容只被初始化一次。

    2、非要用双重加锁的话,变量前加volatile关键字(jdk5+),告知java虚拟机对加volatile的变量的读写不做优化排序。

    package com.demo;
    
    public class Singleton {
    	private Singleton() {
    	}
    
    	public static volatile Singleton instance;
    
    	public static Singleton getInstance() {
    		if (instance == null) {
    			synchronized (Singleton.class) {
    				if(instance == null){
    					instance = new Singleton();
    				}
    			}
    		}
    		return instance;
    	}
    
    }
    

    使用互斥锁,实现双重检查加锁单例模式:

    package com.demo;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Singleton {
    	/**
    	 * 私有构造
    	 */
    	private Singleton() {
    	}
    
    	/**
    	 * 互斥锁
    	 */
    	private static final ReentrantLock lock = new ReentrantLock();
    	public static volatile Singleton instance;
    
    	public static Singleton getInstance() {
    		if (instance == null) {
    			/**
    			 * 锁定访问线程,instance需要被修饰成volatile
    			 */
    			lock.lock();
    			try {
    				if (instance == null) {
    					instance = new Singleton();
    				}
    			} finally {
    				/**
    				 * 解锁
    				 */
    				lock.unlock();
    			}
    
    		}
    		return instance;
    	}
    
    }
    

    高级一点的采用读写锁方式:

    package com.demo;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 单例模式注册类,此类本身使用饿汉式单例模式,用来管理所有的单例对象
     * 
     * @author kk
     * 
     */
    public class SingletonRegister {
    	/**
    	 * 私有构造
    	 */
    	private SingletonRegister() {
    	}
    
    	/**
    	 * 本身单例的引用
    	 */
    	private static final SingletonRegister instance = new SingletonRegister();
    	/**
    	 * 维护注册信息的map
    	 */
    	private static Map<String, Object> map = new HashMap<String, Object>();
    
    	/**
    	 * 多线程的可重入的读写锁
    	 */
    	private static final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    	/**
    	 * 可读锁,可以多个只读锁并存,锁定时可写锁不可用
    	 */
    	private static final Lock rLock = rwLock.readLock();
    	/**
    	 * 可写锁,只能有一个,锁定时其它锁不可用
    	 */
    	private static final Lock wLock = rwLock.writeLock();
    
    	public static Object getInstance(String className)
    			throws InstantiationException, IllegalAccessException,
    			ClassNotFoundException {
    		Object instance = null;
    		// 锁定读取锁
    		rLock.lock();
    		instance = map.get(className);
    		try {
    			if (instance != null) {
    				return instance;
    			}
    		} finally {
    			// 释放读取锁
    			rLock.unlock();
    		}
    
    		// 锁定写入的锁
    		wLock.lock();
    		try {
    			instance = map.get(className);
    			if (instance != null) {
    				return instance;
    			}
    
    			// 使用反射方式实例化单例对象
    			instance = Class.forName(className).newInstance();
    			// 放入map中存储
    			map.put(className, instance);
    
    		} finally {
    			wLock.unlock();
    		}
    		return instance;
    	}
    
    }
    

    利用虚拟机特性,内部类方式实现单例模式:

    package com.demo;
    
    public class Singleton {
    	/**
    	 * 私有构造
    	 */
    	private Singleton() {
    	}
    
    	public static Singleton getInstance() {
    		return SingletonHolder.instance;
    	}
    
    	/**
    	 * 内部类
    	 * @author kk
    	 *
    	 */
    	public static class SingletonHolder {
    		private static final Singleton instance = new Singleton();
    	}
    
    }
    
    内部类在使用到的时候,才开始加载初始化,由java虚拟机保证了线程安全以及延时加载。


    总结:多线程总使用单例模式的建议是不要使用任何双重检查模式,优先考虑饿汉式以及内部类的方式实现单例模式即可,越简单越好;







    展开全文
  • PAGE / NUMPAGES java模式之单例模式 单例模式确保一个类只有一个实例自行提供这个实例并向整个系统提供这个实例 特点 1一个类只能有一个实例 2自己创建这个实例 3整个系统都要使用这个实例 例: 在下面的对象图中有...
  • 单例模式java代码

    2017-12-04 19:46:43
    编写一个类LimitInstanceClass,该类最多可以实例化指定个数实例。实例的个数用配置文件InstanceLimit.cfg指定。例如,如果InstanceLimit.cfg的内容为2,则LimitInstanceClass最多可以同时存在2个对象。...
  • java单例模式1、什么是单例模式1.1、介绍1.2、如何实现单例模式2、饿汉式3、懒汉式4、饿汉式 VS 懒汉式 1、什么是单例模式 1.1、介绍 所谓的单例模式就是指一个类在整个应用程序中只能出现一个对象实例 单例的实现...

    1、什么是单例模式

    1.1、介绍

    1. 所谓的单例模式就是指一个类在整个应用程序中只能出现一个对象实例
    2. 单例的实现方法有两种
      • 饿汉式
      • 懒汉式

    1.2、如何实现单例模式

    实现单例模式大致可分为三个步骤

    1. 私有化构造器 ===>防止被new
    2. 在类内部创建对象
    3. 对外暴露一个静态方法.用于获取对象示例

    2、饿汉式

    public class SingletonPattern {
        public static void main(String[] args) {
            //测试饿汉模式
            EagerSingleton eagerSingleton01=EagerSingleton.getEagerSingleton();
            EagerSingleton eagerSingleton02=EagerSingleton.getEagerSingleton();
            //因为类没有重写toString方法所以会打印地址值
            System.out.println("eagerSingleton01:"+eagerSingleton01);
            System.out.println("eagerSingleton02:"+eagerSingleton02);
    //        结果:
    //        eagerSingleton01:EagerSingleton@1b6d3586
    //        eagerSingleton02:EagerSingleton@1b6d3586
        }
    }
    //步骤[单例模式-饿汉式]
    //1. 将构造器私有化
    //2. 在类的内部直接创建对象(该对象是 static)
    //3. 提供一个公共的 static 方法,返回对象
    class EagerSingleton{
        private static EagerSingleton eagerSingleton=new EagerSingleton();
    
        public static EagerSingleton getEagerSingleton(){
            return eagerSingleton;
        }
    }
    

    3、懒汉式

    public class SingletonPattern {
        public static void main(String[] args) {
            //测试饿汉模式
            LazySingleton lazySingleton01=LazySingleton.getLazySingleton();
            LazySingleton lazySingleton02=LazySingleton.getLazySingleton();
            //因为类没有重写toString方法所以会打印地址值
            System.out.println("lazySingleton01:"+lazySingleton01);
            System.out.println("lazySingleton02:"+lazySingleton02);
    //        结果:
    //        lazySingleton01:LazySingleton@1b6d3586
    //        lazySingleton02:LazySingleton@1b6d3586
        }
    }
    //步驟[单例模式-懒汉式]
    //1.构造器私有化
    //2.定义一个static的对象
    //3.提供一个 public 的 static 方法,可以返回一个懒汉式对象
    //4.懒汉式,只有当用戶使用 getInstance 时,才返回对象, 后面再次调用,会返回上次创建的对象
    class LazySingleton{
        private static LazySingleton lazySingleton;
        
        public static LazySingleton getLazySingleton(){
            if(lazySingleton==null){
                lazySingleton=new LazySingleton();
            }
            return lazySingleton;
        }
    }
    

    4、饿汉式 VS 懒汉式

    1. 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。
    2. 饿汉式不存在线程安全问题,懒汉式存在线程安全问题。
    3. 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用,那么饿汉式.二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。就不存在这个问题了
    展开全文
  • Java实现多种单例模式

    2017-11-30 19:05:20
    通过Java语言,主要实现了六种单例的生成方法,包括懒汉式、饿汉式、双重校验锁、枚举、静态内部类,可以根据实际情况选择使用
  • ## 单例模式是最简单也是最基础的设计模式之一,下边一起学习一下单例模式! 一.单例模式的定义: 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志...
  • java 单例模式 ---饿汉式懒汉式

    千次阅读 多人点赞 2022-01-28 13:37:37
    目录 单例设计模式 饿汉式 懒汉式 饿汉式vs懒汉式 ...饿汉式:在程序启动或单例模式类被加载的时候,单例模式实例就已经被创建。 上例子! package com.happy.demo; public class Singleton...
  • 主要介绍了java 单例模式的相关资料,这里对懒汉式与饿汉式都做了实例介绍,需要的朋友可以参考下
  • 单例模式的定义2. 单例模式的设计要素3. 单例模式的6种实现及各实现的优缺点3.1 懒汉式(线程不安全)3.2 饿汉式(线程安全)3.3 懒汉式(线程安全)3.4 双重检查锁实现(线程安全)3.5 静态内部类实现(线程安全)...
  • 文章目录设计模式-单例模式懒汉模式怎么解决线程安全问题?1.使用双重校验锁2.volatile 修饰实例对象,禁止指令重排序线程安全的懒汉模式饿汉模式 设计模式-单例模式 啥是单例模式? 这种模式涉及到一个单一的类,该...
  • 主要介绍了Java设计模式编程中的单例模式和简单工厂模式以及实例,使用设计模式编写代码有利于团队协作时程序的维护,需要的朋友可以参考下
  • Java单例模式的5种实现方法

    万次阅读 多人点赞 2018-09-06 11:23:22
    单例模式有5种实现方式:饿汉、懒汉、双重校验锁、静态内部类和枚举 饿汉 类加载的时候就创建了实例 优点:类加载的时候创建一次实例,避免了多线程同步问题 缺点:即使单例没被用到也会创建,浪费内存 public ...
  • 主要介绍了Java单例模式、饥饿模式代码实例,本文直接给出代码实例,需要的朋友可以参考下
  • 单例模式java代码实现)

    万次阅读 多人点赞 2018-08-22 16:28:07
    应用单例模式时,类只能有一个对象实例,这么做的目的是避免不一致状态。 饿汉式单例:(立即加载) // 饿汉式单例 public class Singleton1 { // 指向自己实例的私有静态引用,主动创建 private static ...
  • 各个资料都在一个WORD钟,代码全面,复制粘贴即可运行
  • 使用java客户端连接Redis 集群,并使用java进行简单的操作
  • Java单例模式是什么

    2021-03-06 18:46:41
    Java单例模式是什么时间:2017-07-14来源:华清远见JAVA学院Java单例模式简介在GoF的23种设计模式中,单例模式是比较简单的一种。然而,有时候越是简单的东西越容易出现问题。下面就单例设计模式详细的探讨一下。...
  • NULL 博文链接:https://tim-fly.iteye.com/blog/1621579
  • java单例模式

    2021-03-06 06:25:11
    单例模式就是始终是一个对象实例.它对外不提供构造函数,因此我们不能够同时产生多个对象.(常用语工具类,数据库连接类等等)单例模式的调用:因为单例模式的构造方法是私有的,所以在其他类中我们是没有办法直接实例化它...
  • Java单例模式例子

    2017-06-08 12:16:34
    Java 单例模式的实例代码
  • java单例模式的五种实现方式

    千次阅读 2020-05-23 15:56:28
    基于java实现到单例模式
  • JAVA单例模式

    2021-02-12 18:32:20
    定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。类型:创建类模式类图:类图知识点:1....单例模式应该是23种设计模式中最简单的一种模式了。它有以下几个要素:• 私有的...
  • Java多线程单例模式

    2021-02-27 10:24:35
    单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。正是由于这个特点,单例对象通常作为程序中的存放配置信息的载体,因为它能保证其他对象读到一致的...
  • 主要给大家介绍了关于Java单例模式推荐的两种模式,文中通过示例代码介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • Java中实现完整的单例模式

    多人点赞 热门讨论 2020-01-25 19:22:35
    个人认为单例模式是设计模式中最简单也是最常用的一种,是对有限资源合理利用的一种方式。这个模式看似简单,但是其中蕴含了关于并发、类加载、序列化等一系列深层次的知识,如果理解不够深,就有可能在高并发时遇到...
  • public class Component{ private volatile static Component INSTANCE; private Component() {} public static Component getInstance(){ if (INSTANCE== null) { synchronized (Component.class) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,595
精华内容 63,438
关键字:

java单例模式代码

java 订阅