精华内容
下载资源
问答
  • 面试官让你手写单例模式
    2021-03-08 04:06:59

    第一次听说让写设计模式,我都懵了,但是还真有让手写的呢,今天来手写一波单例模式。

    单例模式,也就是一个实例呗,当我们获得对象的时候,每次获得的都是同一个,那么我们可以先创建好一个实例,然后写一个get方法,每次创建的时候,通过get方法获取该实例,那么就达到了单例效果,需要注意的是,我们要私有构造方法,以免外面new对象。

    public class Singleton {public static Singleton instance = new Singleton();private Singleton(){}public static Singleton getInstance() {return instance;}}

    这种写法,习惯上称之为“饿汉式”,原因很简单,因为在获取对象之前都创建好了,感觉“很饿”,这样其实不好,因为我都没有用到这个对象,你都创建了,多浪费呀,说的也是,于是我们改为,当用到的时候,我们判断instance是否为null,如果为null,我们就创建,否则就直接return。

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

    这种方式是等用到了才去创建,给人的感觉是很懒,所以又叫“懒汉式”,仔细看看这种写法,其实存在线程安全问题,当有多线程调用getInstance方法的时候,第一个线程判断instance为null,进入了 if,当还没来得及创建对象的时候,第二个线程也判断instance为null,也进入了 if,于是就会创建多个对象,无法达到单例效果,所以我们就引入了锁,也就是synchronized

    public class Singleton{public static Singleton instance;private Singleton(){}public static synchronized Singleton getInstance(){if (instance == null) {instance = new Singleton();}return instance;}}

    这样有效的解决了线程安全的问题,但是,这个锁,锁到了方法上,范围有点大了,其实我们只需要锁出现线程安全的一部分就行了,于是又来了新版本

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

    这样一来,只锁了new对象的那一部分,当线程来了的时候,我先判断instance是否为空,为空就上锁,不空直接return,但是问题来了,当出现多线程时,第一个线程判断instance为null,进入锁,还没来得及创建对象,第二个线程来了判断instance也为null,当第一个线程走了之后,第二个线程也进入了锁,执行了new,这样线程也不安全了,于是出现了**终极版!**,也叫做DCL(Double Check Lock)

    public class Singleton {public static Singleton instance;private Singleton(){}public static Singleton getInstance() {if (instance == null) { Check onesynchronized (Singleton.class) {if (instance == null) { Check twoinstance = new Singleton();}}}return instance;}}

    这样一来,多线程的情况下,当多个线程进入了第一个 if,但是当第一个 if 执行完毕后,其他线程就算进入锁,也无法通过第二个 if 判断。

    更多相关内容
  • java手写单例模式

    2021-07-21 14:26:04
    -- 懒汉模式 --> private class Singleton{ private Singleton singleton; private Singleton{ } private Singleton getInstance(){ if(singleton == null){ singleton = new Singleton(); } } } &...
    <!-- 懒汉模式 -->
    private class Singleton{
    	private Singleton singleton;
    	private Singleton{
    	}
    	private Singleton getInstance(){
    		if(singleton == null){
    			singleton = new Singleton();
    		}
    	}
    }
    
    <!-- 饿汉模式 -->
    public class Singleton{
    	private Singleton singleton = new Songleton();
    	private Singleton(){
    
    	}
    	public Singleton getSingleton(){
    		return singleton;
    	}
    }
    
    
    <!-- 静态内部类 -->
    public class Singleton{
    	public static class SingletonHolder{
    		private static Singleton instance = new Singleton();
    	}
    
    	public static Singleton getInstance{
    		return SingletonHolder.instance;
    	}
    }
    
    
    展开全文
  • java手写一个单例模式

    2020-04-28 17:23:37
    目录什么是单例模式?使用单例模式的目的?懒汉式恶汉式懒汉式 双重...单例模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在 懒汉式 线程不安全单例模式 public class Singleton { private stati...

    什么是单例模式?

    1. 单例类只能有一个实例
    2. 单例类必须自己创建自己的唯一实例
    3. 单例类必须给所有其他对象提供这一实例

    使用单例模式的目的?

    单例模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在

    懒汉式

    线程不安全单例模式

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

    缺陷: 线程不安全,如果两个线程同时访问到了getInstance()方法,并且都走到了“instance == null”这个判断时,此时instance实例未被创建,所以两个线程都会创建一个实例
    改进: 加上同步锁

    public class Singleton {  
        private static Singleton instance;  
        private Singleton (){} 
        public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
        }  
    }
    

    优点: 第一次调用才初始化,避免内存浪费
    缺点: 必须加锁 synchronized 才能保证单例,但加锁会影响效率

    恶汉式

    public class Singleton {  
        private static Singleton instance = new Singleton();  
        private Singleton (){} 
        public static Singleton getInstance() {  
        return instance;  
        }  
    }
    

    饿汉式更为安全,在类加载的时候就已经自行创建了实例,getinstance方法里面一直引用的就是这个实例,而且永远不会释放,一直存在内存中,知道程序结束
    优点: 没有加锁,执行效率会提高。
    缺点: 类加载时就初始化,浪费内存。

    懒汉式 双重锁

    public class Singleton {  
        private volatile static Singleton singleton;  
    	private Singleton (){} 
        public static Singleton getSingleton() {  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
            }  
        }  
        return singleton;  
        }  
    }
    
    • 其中用了两个if 判断,第一个if 先判断singleton是否为null,如果不为null,说明singleton 已经被初始化了,直接返回singleton
    • 如果singleton 为null ,说明singleton 还没有被初始化,这样才会去执行synchronized 修饰的代码块内容,只在其初始化的时候调用一次。
    • 这样的设计既能保证只产生一个实例,并且只在初始化的时候加同步锁,也实现了延迟加载。
    展开全文
  • 单例设计模式单例模式特点:饿汉式方式一方式二枚举类方式方式三静态代码块方式饱汉式方式一方式二线程安全版方式三静态内部类 单例模式特点: 1、单例类只能有一个实例(构造器私有化)。  2、单例类必须自己创建...

    单例模式特点:

    1、单例类只能有一个实例(构造器私有化)。
      2、单例类必须自己创建自己的唯一实例(含有一个该类的静态变量来保存这个唯一的实例)。
      3、单例类必须给所有其他对象提供这一实例

    饿汉式

    饿汉式:直接创建对象,不存在线程安全问题,不管你是否需要这个对象都会创建

    方式一

    public class Singleton1 {
      
        public static final Singleton1  INSTANCE=new Singleton1();
          // 私有构造
        private Singleton1(){
    
        }
    }
    

    方式二枚举类方式

    最简洁

    public enum Singleton2 {
        SINGLETON_2
    }
    

    方式三静态代码块方式

    public class Singleton3 {
    
        public static final Singleton3 INSTANCE;
        private Singleton3(){
    
        }
    
        static {
            INSTANCE=new Singleton3();
        }
    }
    

    懒汉式

    延迟创建这个对象

    构造器私有化
    用一个静态变量保存这个唯一的实例
    提供一个静态方法,获取这个实例对象

    方式一

    有线程安全问题

    public class Singleton4 {
        private static Singleton4 instance;
        private Singleton4(){
    
        }
        public static Singleton4 getInstance(){
            if(instance==null){
                instance=new Singleton4();
            }
            return instance;
        }
    }
    

    假设有两个线程刚好第一个线程进入getInstance()并判断此时不为null,在还没new之前让出cpu执行权,此时第二个线程刚好进入,也为null,因此就创建了两个不一样的对象

    方式二线程安全版

    public class Singleton5 {
        private static Singleton5 instance;
        private Singleton5(){
    
        }
        public static Singleton5 getInstance(){
            if(instance==null){
                synchronized (Singleton5.class){
                    if(instance==null){
                        instance=new Singleton5();
                    }
                }
            }
            
            return instance;
        }
    }
    

    方式三静态内部类

    在内部类被加载和初始化时,才创建INSTANCE实例对象
    静态内部类不会自动随着外部类的加载和初始化而初始化,它是要去单独加载和初始化的
    因为内部类加载和初始化时创建的,因此是线程安全的

    public class Singleton6 {
        private Singleton6(){
            
        }
        private static class Inner{
            private static final Singleton6 INSTANCE=new Singleton6();
            
        }
        public static Singleton6 getInstance(){
            return Inner.INSTANCE;
        }
    }
    
    展开全文
  • 手写单例模式-java

    2019-07-18 15:48:00
  • Java面试手写单例模式的三种实现 单例模式实现方法: 饿汉式单例:在类初始化时就已经自行实例化了 public class Singleton { //私有静态成员变量 private static Singleton instance = new Singleton(); //...
  • 单例模式(Singleton pattern):确保一个类只有一个实例,并提供该实例的全局访问点 本文主要分析单例模式常见的几种实现方式 一. 类图 单例模式使用一个私有构造函数、一个私有静态变量以及一个公有静态函数...
  • 为什么要有单例模式实际编程应用场景中,有一些对象其实我们只需要一个,比如线程池对象、缓存、系统全局配置对象等。这样可以就保证一个在全局使用的类不被频繁地创建与销毁,节省系统资源。实现单例模式的几个要点...
  • 笔试题:请手写一个Singleton(单例模式)?答:暂时不会。不堪回首,原谅我的洒脱!之前见过单例模式,万万没有想到手撕代码,哦豁,还是不会。 本文整理了几种常见的单例模式代码示例,理解单例模式。再
  • (1)单例饿汉模式://饿汉式单例类.在类初始化时,已经自行实例化public class Singleton1{ //私有的默认构造子private Singleton1() {}//已经自行实例化private static final Singleton1 single = new Singleton1(); ...
  • 手写五种单例模式

    千次阅读 2020-09-02 09:34:35
    这段代码简单明了,而且使用了懒加载模式,但是却存在致命的问题。当有多个线程并行调用 getInstance() 的时候,就会创建多个实例。也就是说在多线程下不能正常工作 public class Singleton{ private static ...
  • 手写单例模式

    2020-09-25 01:12:57
    1. 静态内部类实现单例(线程安全、效率高) 一。静态内部类实现:这种方式是 Singleton 类被装载了, instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用,只有通过显示调用 getInstance 方法时,才...
  •   单例模式的主要特点:构造方法私有化,外部无法产生新的实例化对象,只能通过static方法取得实例化对象。 例子:懒汉式单例模式 class Singleton { private static Singleton singleton ; private...
  • 第一种:饿汉模式(线程安全)publicclassSingle2{privatestaticSingle2instance=newSingle2();privateSingle2(){System.out.println("Single2:"+System.nanoTime());}publicstaticSingle2getInstance(){returnin...
  • Java-手写单例模式

    2019-10-07 17:54:57
    public ...//调用单例模式中的对象 public static void main ( String [ ] args ) { Singleton singleton = Singleton . getInstance ( ) ; singleton . run ( ) ; }
  • 创建单例类的步骤: 1、私有化该类的构造函数。 2、通过new在本类中创建一个本类对象。 3、提供一个公有的静态方法,将创建的对象返回。...单例模式懒汉式和饿汉式区别? 饿汉式天生就是线程安全的,可以直.
  • 单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。正是因为简单,也成为面试中的众矢之的。本文来手写单例模式
  • 饿汉式 class LazyMan{ private LazyMan(){}; private static LazyMan lazyMan = new LazyMan(); public static LazyMan getLazyMan(){ return lazyMan; } ... private static LazyMan laz
  • 面试题:手写单例模式面试题:手写单例模式二级目录三级目录 面试题:手写单例模式 二级目录 三级目录
  • 设计模式之单例模式-java

    千次阅读 2021-11-23 17:02:06
    单例模式 什么是单例模式 我们知道单例模式顾名思义就是一个类只有一个实例对象,且不能通过 new 来创建该类的实例对象 ,当外部想要拿到这个类的实例的时候,不能直接获取,需要通过调用该类的方法 getInstance ...
  • 创建型模式:5种,工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式 结构型模式:7种,适配器模式,装饰者模式,代理模式,外观模式,桥接模式,组合模式,享元模式 行为型模式:11种,策略模式,模板...
  • 通过单例模式的方法创建的类在当前进程中只有一个实例(根据需要,也有可能一个线程中属于单例,如:仅线程上下文内使用同一个实例),就是说每次我们创建的对象成功以后,在一个线程中有且仅有一个对象在正常使用。...
  • 在企业级开发中,我们...这个模式也被总结为一种设计模式:资源池模式和单例模式。 关于原理部分就不多做介绍了,这里也是做一个简单的原理实现。ObjectPool连接池接口package com.test.pool;import java.util.En...
  • 说实话,看到这个问题,我心里还是有点窃喜的~ 单例模式?不好意思,设计模式我只会单例,哈哈哈,看我一顿操作:publicclassSingleton{privatestaticSingletonsingleton=null;privateSingleton(){}...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,315
精华内容 4,126
关键字:

手写单例模式java

java 订阅