365bet体育在线网投Python中__new__()方法的采用和实例化

365bet体育在线网投 1

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(Stranger, *args, **kwargs)  

class Stranger(object):
    ...

foo = Foo()
print type(foo)  

2.4 使用单例方式重写示例

要选择单例方式来重写示例,由于单例情势有二种完结格局,这里选一种来兑现就好了,就分选饿汉式的兑现形式来重写示例吧。拔取饿汉式的贯彻形式来重写实例的演示代码如下:

/**
 * 读取应用配置文件,单例实现
 */  
public class AppConfig {  
    /**
     * 定义一个变量来存储创建好的类实例,直接在这里创建类实例,只会创建一次
     */  
    private static AppConfig instance = new AppConfig();  
    /**
     * 定义一个方法来为客户端提供AppConfig类的实例
     * @return 一个AppConfig的实例
     */  
    public static AppConfig getInstance(){  
        return instance;  
    }  

    /**
     * 用来存放配置文件中参数A的值
     */  
    private String parameterA;  
    /**
     * 用来存放配置文件中参数B的值
     */  
    private String parameterB;  
    public String getParameterA() {  
        return parameterA;  
    }  
    public String getParameterB() {  
        return parameterB;  
    }  
    /**
     * 私有化构造方法
     */  
    private AppConfig(){  
        //调用读取配置文件的方法  
        readConfig();  
    }  
    /**
     * 读取配置文件,把配置文件中的内容读出来设置到属性上
     */  
    private void readConfig(){  
        Properties p = new Properties();  
        InputStream in = null;  
        try {  
            in = AppConfig.class.getResourceAsStream("AppConfig.properties");  
            p.load(in);  
            //把配置文件中的内容读出来设置到属性上  
            this.parameterA = p.getProperty("paramA");  
            this.parameterB = p.getProperty("paramB");  
        } catch (IOException e) {  
            System.out.println("装载配置文件出错了,具体堆栈信息如下:");  
            e.printStackTrace();  
        } finally {  
            try {  
                in.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }    
}

本来,测试的客户端也必要相应的变更,示例代码如下:

public class Client {  
    public static void main(String[] args) {  
        //创建读取应用配置的对象  
        AppConfig config = AppConfig.getInstance();  

        String paramA = config.getParameterA();  
        String paramB = config.getParameterB();  

        System.out.println("paramA="+paramA+",paramB="+paramB);  
    }
}

[深入Python]__new__和__init__

1
2
3
4
5
6
7
8
class A(object):
    def __init__(self):
        print "init"
    def __new__(cls,*args, **kwargs):
        print "new %s"%cls
        return object.__new__(cls*args, **kwargs)
 
A()

输出:

new <class
‘__main__.A’>
init

 

知识点:

后续自object的风行类才有__new__

__new__最少要有二个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供

__new__总得要有再次回到值,再次来到实例化出来的实例,那点在投机达成__new__时要尤其注意,可以return父类__new__出来的实例,恐怕间接是object的__new__出来的实例

__init__有多少个参数self,就是以此__new__回到的实例,__init__在__new__的底子上可以做到部分任何初叶化的动作,__init__不须求再次来到值

若__new__没有科学重返当前类cls的实例,那__init__是不会被调用的,尽管是父类的实例也极度

1
2
3
4
5
6
7
8
9
10
11
12
class A(object):
    pass
 
class B(A):
    def __init__(self):
        print "init"
    def __new__(cls,*args, **kwargs):
        print "new %s"%cls
        return object.__new__(A, *args, **kwargs) #返回了A的一个实例
 
b=B()
print type(b)

 输出:

new <class
‘__main__.B’>
<class ‘__main__.A’>

 

详见表明可参考:

365bet体育在线网投 2

打印的结果突显foo其实是Stranger类的实例。

3.8 在Java中一种更好的单例完成格局

依照下面的分析,常见的两种单例完毕形式都存在小小的后天不足,那么有没有一种方案,既可以落实延迟加载,又可以达成线程安全吗?

还真有哲人想到那样的化解方案了,这个解决方案被称为Lazy initialization holder class模式,这个模式综合使用了Java的类级内部类和多线程缺省同步锁的知识,很巧妙的同时实现了延迟加载和线程安全

  1. 先来看点相应的基础知识

    怎么样是类级内部类?不难点说,类级内部类指的是:有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类

    类级内部类也等于其表面类的static成分,它的目的与外表类对象间不存在依靠关系,因而可直接开立。而目的级内部类的实例,是绑定在外表对象实例中的。

    类级内部类中,可以定义静态的章程,在静态方法中只可以够引用外部类中的静态成员方法可能成员变量。

    类级内部类相当于其外部类的积极分子,唯有在首先次被采纳的时候才会被装载。

    再来看看三十二线程缺省同步锁的学识。

    世家都领悟,在多线程开发中,为了解决并发问题,主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中,JVM已经隐含地为您执行了同步,那几个情况下就毫无本身再来举办同步控制了。这个情形包涵:

    由静态起先化器(在静态字段上或 static{}
    块中的初阶化器)初阶化数据时

    访问 final 字段时

    在开立线程此前创造对象时

    线程可以望见它将要处理的目的时

  2. 接下去看看那种消除方案的思绪

    要想很简单的完结线程安全,可以采用静态初始化器的方式,它可以由JVM来保证线程安全性。比如前边的“饿汉式”完毕形式,可是那样一来,不是会浪费一定的上空吗?因为那种达成格局,会在类装载的时候就开首化对象,不管你需不须求。

    若是今日有一种形式可以让类装载的时候不去初叶化对象,那不就化解难题了?一种可行的方式就是采用类级内部类,在这个类级内部类里面去创建对象实例,这样一来,只要不使用到这个类级内部类,那就不会创建对象实例。从而同时落到实处延迟加载和线程安全。

    看望代码示例或然会更显然,示例代码如下:

    public class Singleton {  
      /**
       * 类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
       * 没有绑定关系,而且只有被调用到才会装载,从而实现了延迟加载
       */  
      private static class SingletonHolder {  
          /**
           * 静态初始化器,由JVM来保证线程安全
           */  
          private static Singleton instance = new Singleton();  
      }  
      /**
       * 私有化构造方法
       */  
      private Singleton() {  
      }  
      public static  Singleton getInstance() {  
          return SingletonHolder.instance;  
      }  
    }
    

    周到考虑,是或不是很巧妙呢!

    当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance,导致SingletonHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建Singleton的实例,由于是静态的域,因此只会被虚拟机在装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。

    本条格局的优势在于,getInstance方法并没有被一道,并且只是履行二个域的拜访,因而延迟开始化并不曾伸张其他访问开支。

[Python] Python 之 __new__() 方法与实例化

__new__()
是在风行类中新出现的格局,它效能在构造方法建造实例在此之前,可以那样掌握,在
Python 中留存于类里面的构造方法 __init__() 负责将类的实例化,而在
__init__() 运营以前,__new__() 决定是不是要动用该 __init__()
方法,因为__new__()
可以调用其余类的构造方法大概直接回到其他对象来作为本类的实例。

 

设若将类比喻为工厂,那么__init__()方法则是该工厂的生产工人,__init__()方法接受的开首化参数则是生育所需原料,__init__()方法会根据办法中的语句负责将原料加工成实例以供工厂出货。而__new__()则是生产部主管,__new__()方法可以控制是或不是将原料提要求该生产部工人,同时它还控制着出货产品是不是为该生产部的产品,因为那名COO可以借该工厂的名义向客户出售完全不是该工厂的成品。

 

__new__() 方法的特色:

  • __new__()
    方法是在类准备将本身实例化时调用。
  • __new__()
    方法始终都是类措施,固然没有被添加类方式装饰器。
  • 类的实例化和它的构造方法日常都是这一个样子:

365bet体育在线网投 3

class MyClass(object):
    def __init__(self, *args, **kwargs):
        ...

# 实例化
myclass = MyClass(*args, **kwargs)

365bet体育在线网投 4

  

比较以上所示,三个类可以有三个地点参数和七个命名参数,而在实例化先河之后,在调用
__init__() 方法以前,Python 首先调用 __new__() 方法:

def __new__(cls, *args, **kwargs):
    ...

  

先是个参数cls是近日正值实例化的类。

  • 万一要博取当前类的实例,应当在当前类中的
    __new__() 方立陶宛语句中调用当前类的父类的 __new__()
    方法。

  例如,倘若当前类是直接接轨自
object,那当前类的 __new__() 方法重返的对象应当为:

def __new__(cls, *args, **kwargs):
    ...
    return object.__new__(cls)

  

注意:

  事实上假若(新式)类中没有重写__365bet体育在线网投,new__()方法,即在概念新型类时没有再度定义__new__()时,Python暗中承认是调用该类的直白父类的__new__()方法来布局该类的实例,若是此类的父类也未曾重写__new__(),那么将直接按此规矩追溯至object的__new__()方法,因为object是有所新式类的基类。

 

  而倘使新式类中重写了__new__()方法,那么你可以自由选取任意三个的其他的新式类(必定如果新式类,只有新型类必定都有__new__(),因为兼具最新类都是object的后人,而经典类则尚未__new__()方法)的__new__()方法来创设实例【本身明白:实际上并不是自由选取任二个新式类,而是无度2个男子级其余新式类,因为兼具兄弟的__new__()方法重返的都以同1个父类的__new__()方法,实际上约等于终极必须是用直白的父类的__new__()方法,不可以用到曾外祖父级其他,也不大概用到岳丈级其他】,包罗这一个新式类的兼具前代类和后人类,只要它们不会导致递归死循环。具体看以下代码解释:

 

365bet体育在线网投 5

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)    

# 以上return等同于 
# return object.__new__(Foo, *args, **kwargs)
# return Stranger.__new__(cls, *args, **kwargs)
# return Child.__new__(cls, *args, **kwargs)

class Child(Foo):
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)

# 如果Child中没有定义__new__()方法,那么会自动调用其父类的__new__()方法来制造实例,即 Foo.__new__(cls, *args, **kwargs)。
# 在任何新式类的__new__()方法,不能调用自身的__new__()来制造实例,因为这会造成死循环。因此必须避免类似以下的写法:
# 在Foo中避免:return Foo.__new__(cls, *args, **kwargs)或return cls.__new__(cls, *args, **kwargs)。Child同理。
# 使用object或者没有血缘关系的新式类的__new__()是安全的,但是如果是在有继承关系的两个类之间,应避免互调造成死循环,例如:(Foo)return Child.__new__(cls), (Child)return Foo.__new__(cls)。

class Stranger(object):
    ...
# 在制造Stranger实例时,会自动调用 object.__new__(cls)

365bet体育在线网投 6

 

  •  日常来说,新式类开端实例化时,__new__()方法会重返cls(cls指代当前类)的实例,然后该类的__init__()方法作为协会方法会接收那一个实例(即self)作为团结的率先个参数,然后挨家挨户传入__new__()方法中吸收的地方参数和命名参数。

 

注意:如果__new__()没有再次来到cls(即当前类)的实例,那么当前类的__init__()方法是不会被调用的。假如__new__()再次回到其余类(新式类或经典类均可)的实例,那么只会调用被重回的十二分类的构造方法【自身实际操作了须臾间,重返的是其余类的实例,但是并从未调用其他的充足类的构造方法__init__()】。

365bet体育在线网投 7

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(Stranger, *args, **kwargs)  

class Stranger(object):
    ...

foo = Foo()
print type(foo)    

# 打印的结果显示foo其实是Stranger类的实例。

# 因此可以这么描述__new__()和__ini__()的区别,在新式类中__new__()才是真正的实例化方法,为类提供外壳制造出实例框架,然后调用该框架内的构造方法__init__()使其丰满。
# 如果以建房子做比喻,__new__()方法负责开发地皮,打下地基,并将原料存放在工地。而__init__()方法负责从工地取材料建造出地皮开发招标书中规定的大楼,__init__()负责大楼的细节设计,建造,装修使其可交付给客户。

365bet体育在线网投 8

 

                                                                                                                                            2018.08.11
周六

 

2.2 格局协会和表达

单例方式社团如图所示:

365bet体育在线网投 9

Singleton:负责创建Singleton类自己的唯一实例,并提供一个getInstance的方法,让外部来访问这个类的唯一实例。

    可以,可以,一遍偶然的座谈竟然也改为了相互心里探讨钻研技术的源点,不错啊。

 

3.3 延迟加载的商量

单例情势的懒汉式完毕格局浮现了延期加载的想想,什么是延迟加载呢?

通俗点说,就是一初阶不要加载资源依然数额,一向等,等到及时快要动用这些能源依旧数额了,躲然而去了才加载,所以也称Lazy
Load,不是懈怠啊,是“延迟加载”,那在实质上支出中是一种很广阔的构思,尽或然的节约财富。

反映在怎么着地点啊?看如下代码:

365bet体育在线网投 10

 

在制作Stranger实例时,会活动调用 object.new(cls) 
平日来说,新式类初步实例化时,new()方法会重回cls(cls指代当前类)的实例,然后该类的 init()方法作为协会方法会接收这些实例(即self)作为团结的首先个参数,然后依次传入new ()方法中接受的职分参数和命名参数。

转自:

                                                                                                                                            于首都天安门

new()是在新型类中新辈出的章程,它效率在构造方法init()建造实例此前,可以如此清楚,在Python
中存在于类里面的构造方法init()负责将类的实例化,而在init()调用在此之前,new()决定是还是不是要选用该init()方法,因为new()可以调用其余类的构造方法恐怕直接回到其他对象来作为本类
的实例。 
假如将类比喻为工厂,那么init()方法则是该工厂的生产工人,init()方法接受的开头化参
数则是生育所需原料,init()方法会依据办法中的语句负责将原料加工成实例以供工厂出货。而 new()则是生产部主任,new()方法可以决定是不是将原料提需求该生产部工人,同时它还控制着出
货产品是不是为该生产部的产品,因为那名CEO可以借该工厂的名义向客户出售完全不是该工厂的成品。 
new()方法的性状: 
new()方法是在类准备将自家实例化时调用。 
new()方法始终都以类的静态方法,尽管没有被拉长静态方法装饰器。

3.5 Java中缓存的着力达成

引申一下,看看在Java开发中的缓存的主导落到实处,在Java中最常见的一种实现缓存的方式就是使用Map,基本的手续是:

先到缓存里面查找,看看是还是不是存在需求利用的数码

假如没有找到,那么就创办1个满意须求的多寡,然后把那一个数据设置回到缓存中,以备下次利用

一经找到了对应的数额,只怕是创制了对应的多少,那就径直行使这么些数量。

依旧看看示例吧,示例代码如下:

/**
 * Java中缓存的基本实现示例
 */  
public class JavaCache {  
   /**
    * 缓存数据的容器,定义成Map是方便访问,直接根据Key就可以获取Value了
    * key选用String是为了简单,方便演示
    */  
   private Map<String,Object> map = new HashMap<String,Object>();  
   /**
    * 从缓存中获取值
    * @param key 设置时候的key值
    * @return key对应的Value值
    */  
   public Object getValue(String key){  
       //先从缓存里面取值  
       Object obj = map.get(key);  
       //判断缓存里面是否有值  
       if(obj == null){  
           //如果没有,那么就去获取相应的数据,比如读取数据库或者文件  
           //这里只是演示,所以直接写个假的值  
           obj = key+",value";  
           //把获取的值设置回到缓存里面  
           map.put(key, obj);  
       }  
       //如果有值了,就直接返回使用  
       return obj;  
   }  
}

这里只是缓存的基本实现,还有很多功能都没有考虑,比如缓存的清除,缓存的同步等等。当然,Java的缓存还有不少落到实处格局,也是非凡复杂的,以后有不少专业的缓存框架,更加多缓存的学问,那里就不再去商讨了。

365bet体育在线网投 11365bet体育在线网投 12

于是得以那样描述new()和ini()的分别,在新型类中new()才是确实的实例化方法,为类提供外壳创制出实例框架,然后调用该框架内的构造方法init()使其丰裕。 
假诺以建房屋做比喻,new()方法负责开发地皮,打下地基,并将原料存放在工地。而init()方法负责从工地取资料建造出地皮开发招标书中规定的楼宇,init()负责大楼的底细设计,建造,装修使其可交付给客户。

2.3 单例情势示例代码

在Java中,单例形式的兑现又分为二种,一种称为懒汉式,一种称为饿汉式,其实就是在切实可行创造对象实例的处理上,有不相同的贯彻形式。上面分别来看那三种已毕形式的代码示例。为什么这么写,具体的在后头再讲述。

  1. 懒汉式完结,示例代码如下:

    /**
    * 懒汉式单例实现的示例
    */  
    public class Singleton {  
     /**
      * 定义一个变量来存储创建好的类实例
      */  
     private static Singleton uniqueInstance = null;  
     /**
      * 私有化构造方法,好在内部控制创建实例的数目
      */  
     private Singleton(){  
         //  
     }  
     /**
      * 定义一个方法来为客户端提供类实例
      * @return 一个Singleton的实例
      */  
     public static synchronized Singleton getInstance(){  
         //判断存储实例的变量是否有值  
         if(uniqueInstance == null){  
             //如果没有,就创建一个类实例,并把值赋值给存储类实例的变量  
             uniqueInstance = new Singleton();  
         }  
         //如果有值,那就直接使用  
         return uniqueInstance;  
     }  
     /**
      * 示意方法,单例可以有自己的操作
      */  
     public void singletonOperation(){  
         //功能处理  
     }  
     /**
      * 示意属性,单例可以有自己的属性
      */  
     private String singletonData;  
     /**
      * 示意方法,让外部通过这些方法来访问属性的值
      * @return 属性的值
      */  
     public String getSingletonData(){  
         return singletonData;  
     }  
    }
    
  2. 饿汉式已毕,示例代码如下:

    /**
    * 饿汉式单例实现的示例
    */  
    public class Singleton {  
      /**
       * 定义一个变量来存储创建好的类实例,直接在这里创建类实例,只会创建一次
       */  
      private static Singleton uniqueInstance = new Singleton();  
      /**
       * 私有化构造方法,好在内部控制创建实例的数目
       */  
      private Singleton(){  
          //  
      }  
      /**
       * 定义一个方法来为客户端提供类实例
       * @return 一个Singleton的实例
       */  
      public static Singleton getInstance(){  
          //直接使用已经创建好的实例  
          return uniqueInstance;  
      }  
    
      /**
       * 示意方法,单例可以有自己的操作
       */  
      public void singletonOperation(){  
          //功能处理  
      }  
      /**
       * 示意属性,单例可以有自己的属性
       */  
      private String singletonData;  
      /**
       * 示意方法,让外部通过这些方法来访问属性的值
       * @return 属性的值
       */  
      public String getSingletonData(){  
          return singletonData;  
      }  
    }
    

 

Foo.__new__(cls, *args, **kwargs)

1 场景难题

 1 <?php
 2 namespace Strategy;
 3 
 4 
 5 //XXXStrategy 具体策略类
 6 class XXXStrategy extends BaseStrategyClass implements IStrategy
 7 {/*{{{*/
 8     public $cooperation;
 9 
10     public function __construct()
11     {
12         $this->cooperation = new XXXCooperation();
13     }
14 
15     //实现策略
16     public function testStrategy($argsOne, $argsTwo)
17     {
18         echo $argsOne." ".$argsTwo;
19     }
20 }/*}}}*/

 

2.1 单例情势来缓解

用来化解上述难点的二个客观的缓解方案就是单例格局。那么怎么样是单例方式吗?

  1. 单例形式定义

    有限支撑贰个类仅有2个实例,并提供3个走访它的大局访问点。

  2. 接纳单例格局来化解的思绪

    密切分析上面的题材,将来壹个类可以被创建八个实例,难点的起点在于类的构造方法是精通的,也等于足以让类的表面来通过构造方法创设三个实例。换句话说,只要类的构造方法能让类的外表访问,就从不章程去决定外部来创制那一个类的实例个数。

    要想控制三个类只被创设一个实例,那么首要的问题就是要把创建实例的权限收回来,让类自身来负责自己类实例的创建工作,然后由这个类来提供外部可以访问这个类实例的方法,这就是单例模式的实现方式

   
然后我们相见的第多少个难点是,此前都以经过工厂方法的构造方法,将策略类的实例作为其属性,使用
(new classFaculty(‘xxx’))->strategyClass
得到政策实例,然后那个政策实例里,可以调用
xxxCooperatioin类中的相关办法,那个是足以走通的,但是若是自己只是想测试 xxxCooperatioin类中的方法,就分外,包蕴测试xxxStrategy类中的方法都以尤其的,都分别报
不存在其 基类 BaceCooperationClass
和BaceStrategyClass不设有,这几个就比较狼狈了,百思不得其解,作者和潇同学“心急火燎”,再细致看看
八个文本 ClassFactory.php ,  xxxCooperatioin.php 和 XXXStrategy.php,
终于发现原来走工厂那种访问的时候,ClassFactory.php
中早就包蕴了 xxxCooperatioin
类和xxxStrategy类所要求的基类了,所以一路走下来,是可以加载各种类的,不过借使是
直接外部测试脚本调用 xxxCooperatioin类
和xxxStrategy类是十分的,因为他俩的基类在 ClassFactory.php中,而你又无法采取命名空间将其加载进来(因为BaceCooperationClass
和BaceStrategyClass
和文件ClassFactory.php的文书名差异等,不能加载),那样就强制外部必须走工厂ClassFactory类
来访问到 xxxCooperatioin类,和xxxStrategy类,那样就增进了安全性,完毕了封装性。

class Stranger(object):
    ...

3 情势教学

365bet体育在线网投 13

class MyClass(object):
   def __init__(self, *args, **kwargs):
       ...
# 实例化
myclass = MyClass(*args, **kwargs)

3.7 单例方式的利弊

  1. 时间和空中

    懒汉式是一级的岁月换空间,相当于每一回拿到实例都会展开判定,看是不是要求创设实例,费判断的时刻,当然,如若平素未曾人利用以来,那就不会创立实例,节约内存空间。

    饿汉式是名列三甲的空间换时间,当类装载的时候就会创立类实例,不管你用不用,先创立出来,然后每一遍调用的时候,就不须求再判断了,节省了运维时刻。

  2. 线程安全

    (1)从线程安全性上讲,不加同步的懒汉式是线程不安全的,比如说:有多个线程,二个是线程A,贰个是线程B,它们同时调用getInstance方法,那就大概导致出现难题。如下示例:

    365bet体育在线网投 14

    次第继续运转,多个线程都向前走了一步,如下:

    365bet体育在线网投 15

    唯恐某些朋友会觉得文字描述如故不够直观,再来画个图说圣元下,如图所示:

    365bet体育在线网投 16

    透过上图的解释描述,鲜明可以看到,当A、B线程并发的动静下,会创制出多个实例来,约等于单例的主宰在出现情状下失效了。

    (2)饿汉式是线程安全的,因为虚拟机保险了只会装载五回,在装载类的时候是不会生出并发的。

    (3)怎么着贯彻懒汉式的线程安全啊?当然懒汉式也是可以落成线程安全的,只要添加synchronized即可,如下:

    public static synchronized Singleton getInstance(){}
    

    但是这样一来,会降低整个访问的速度,而且每次都要判断,也确实是稍微慢点。那么有没有更好的法门来贯彻吗?

    (4)双重检查加锁,可以运用“双重检查加锁”的方式来贯彻,就足以既完结线程安全,又可以使质量不面临大的熏陶。那么什么样是“双重检查加锁”机制吗?

    所谓双重检查加锁机制,指的是:并不是每次进入getInstance方法都需要同步,而是先不同步,进入方法过后,先检查实例是否存在,如果不存在才进入下面的同步块,这是第一重检查。进入同步块过后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例,这是第二重检查。那样一来,就只要求共同一遍了,从而减弱了数十次在一块儿情形下进展判断所浪费的年月。

    双重检查加锁机制的实现会使用一个关键字volatile,它的情致是:被volatile修饰的变量的值,将不会被地面线程缓存,全部对该变量的读写都以一贯操作共享内存,从而确保五个线程能正确的拍卖该变量。

    注意:在Java1.4及以前版本中,很多JVM对于volatile关键字的实现有问题,会导致双重检查加锁的失败,因此双重检查加锁的机制只能用在Java5及以上的版本。

    看望代码可能会更通晓些,示例代码如下:

    public class Singleton {  
      /**
       * 对保存实例的变量添加volatile的修饰
       */  
      private volatile static Singleton instance = null;  
      private Singleton(){      
      }  
      public static  Singleton getInstance(){  
          //先检查实例是否存在,如果不存在才进入下面的同步块  
          if(instance == null){  
              //同步块,线程安全的创建实例  
              synchronized(Singleton.class){  
                  //再次检查实例是否存在,如果不存在才真的创建实例  
                  if(instance == null){  
                      instance = new Singleton();  
                  }  
              }  
          }  
          return instance;  
      }  
    }
    

    那种达成方式既可使完结线程安全的创建实例,又不会对品质造成太大的熏陶,它只是在第2回创制实例的时候一起,将来就不需要一起了,从而加速运维速度。

    提示:由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化,所以运行效率并不是很高,因此一般建议,没有特别的需要,不要使用。约等于说,固然可以动用重复加锁机制来兑现线程安全的单例,但并不指出大量拔取,依照气象来选拔吧。

01 测试脚本test.php

 

3.9 单例和枚举

遵守《高效Java
第2版》中的说法:单元素的枚举类型已经成为实现Singleton的最佳方法

为了驾驭那些理念,先来打听一些相关的枚举知识,那里只是强化和小结一下枚举的一部分重视观点,更四大旨的枚举的采纳,请参看Java编程入门资料:

Java的枚举类型实质上是成效齐全的类,由此可以有投机的个性和方法

Java枚举类型的主旨理维:通过国有的静态final域为各种枚举常量导出实例的类

从有个别角度讲,枚举是单例的泛型化,本质上是单成分的枚举

用枚举来完毕单例卓殊不难,只需求编制三个包蕴单个成分的枚举类型即可,示例代码如下:

/**
 * 使用枚举来实现单例模式的示例
 */  
public enum Singleton {  
    /**
     * 定义一个枚举的元素,它就代表了Singleton的一个实例
     */  
    uniqueInstance;  

    /**
     * 示意方法,单例可以有自己的操作
     */  
    public void singletonOperation(){  
        //功能处理  
    }  
}

使用枚举来实现单实例控制,会更加简洁,而且无偿的提供了序列化的机制,并由JVM从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。

test.php

正如以上所示,3个类可以有多少个义务参数和多少个命名参数,而在实例化先河过后,在调用 init()方法从前,Python首先调用new()方法:

3.6 利用缓存来兑现单例方式

其实使用Java缓存的学问,也足以变相完成Singleton情势,算是二个模拟完成呢。每回都先从缓存中取值,只要创立三次对象实例过后,就设置了缓存的值,那么下次就无须又创立了。

就算不是很正统的做法,然则同样可以达成单例情势的职能,为了简单,先不去考虑二十四线程的难点,示例代码如下:

/**
 * 使用缓存来模拟实现单例
 */  
public class Singleton {  
   /**
    * 定义一个缺省的key值,用来标识在缓存中的存放
    */  
   private final static String DEFAULT_KEY = "One";  
   /**
    * 缓存实例的容器
    */  
   private static Map<String,Singleton> map = new HashMap<String,Singleton>();  
   /**
    * 私有化构造方法
    */  
   private Singleton(){  
       //  
   }  
   public static Singleton getInstance(){  
       //先从缓存中获取  
       Singleton instance = (Singleton)map.get(DEFAULT_KEY);  
       //如果没有,就新建一个,然后设置回缓存中  
       if(instance==null){  
           instance = new Singleton();  
           map.put(DEFAULT_KEY, instance);  
       }  
       //如果有就直接使用  
       return instance;  
   }  
}

原文地址: 【技术文章】《记几次意外的技术切磋收获—策略方式》

 

3.10 思考单例情势

  1. 单例情势的原形

    单例模式的本质:控制实例数目。

    单例格局是为了操纵在运作时期,有个别类的实例数目只可以有1个。只怕有人就会想了,那么作者能无法操纵实例数目为二个,贰个,或然是任意四个呢?目的都以一律的,节省能源啊,有些时候单个实例无法满意实际的内需,会忙可是来,依据计算,三个实例刚刚好,约等于说,将来要控制实例数目为三个,怎么办呢?

    其实思路很简短,就是采用方面通过Map来缓存完成单例的言传身教,举办变形,一个Map可以缓存任意五个实例,新的难题不怕,Map中有多少个实例,不过客户端调用的时候,到底重回这一个实例呢,相当于实例的调度难题,我们只是想要来显示设计形式,对于这一个调度算法就不去商量了,做个最简便的,循环再次来到就好了,示例代码如下:

    /**
    * 简单演示如何扩展单例模式,控制实例数目为3个
    */  
    public class OneExtend {  
      /**
       * 定义一个缺省的key值的前缀
       */  
      private final static String DEFAULT_PREKEY = "Cache";  
      /**
       * 缓存实例的容器
       */  
      private static Map<String,OneExtend> map = new HashMap<String,OneExtend>();  
      /**
       * 用来记录当前正在使用第几个实例,到了控制的最大数目,就返回从1开始
       */  
      private static int num = 1;  
      /**
       * 定义控制实例的最大数目
       */  
      private final static int NUM_MAX = 3;  
      private OneExtend(){}  
      public static OneExtend getInstance(){  
          String key = DEFAULT_PREKEY+num;  
          //缓存的体现,通过控制缓存的数据多少来控制实例数目  
          OneExtend oneExtend = map.get(key);  
          if(oneExtend==null){  
              oneExtend = new OneExtend();  
              map.put(key, oneExtend);  
          }  
          //把当前实例的序号加1  
          num++;  
          if(num > NUM_MAX){  
              //如果实例的序号已经达到最大数目了,那就重复从1开始获取  
              num = 1;  
          }  
          return oneExtend;        
      }  
    
      public static void main(String[] args) {  
          //测试是否能满足功能要求  
          OneExtend t1 = getInstance ();  
          OneExtend t2 = getInstance ();  
          OneExtend t3 = getInstance ();  
          OneExtend t4 = getInstance ();  
          OneExtend t5 = getInstance ();  
          OneExtend t6 = getInstance ();  
    
          System.out.println("t1=="+t1);  
          System.out.println("t2=="+t2);  
          System.out.println("t3=="+t3);  
          System.out.println("t4=="+t4);  
          System.out.println("t5=="+t5);  
          System.out.println("t6=="+t6);  
      }  
    }
    

    测试一下,看看结果,如下:

    t1==cn.javass.dp.singleton.example9.OneExtend@6b97fd  
    t2==cn.javass.dp.singleton.example9.OneExtend@1c78e57  
    t3==cn.javass.dp.singleton.example9.OneExtend@5224ee  
    t4==cn.javass.dp.singleton.example9.OneExtend@6b97fd  
    t5==cn.javass.dp.singleton.example9.OneExtend@1c78e57  
    t6==cn.javass.dp.singleton.example9.OneExtend@5224ee
    
  2. 曾几何时选取单例形式

    提出在如下处境中,拔取单例情势:

    当需要控制一个类的实例只能有一个,而且客户只能从一个全局访问点访问它时,可以选用单例模式,这些功能恰好是单例模式要解决的问题。

©
作品权归小编全部

  • 分类:空话设计情势
  • 字数:8936

365bet体育在线网投 17365bet体育在线网投 18

 

0 名目繁多目录

  • 白话设计格局
    • 厂子形式
    • 单例方式
    • 【白话设计形式一】简单工厂情势(Simple
      Factory)
    • 【白话设计格局二】外观形式(Facade)
    • 【白话设计格局三】适配器形式(Adapter)
    • 【白话设计形式四】单例方式(Singleton)
    • 【白话设计方式五】工厂方法方式(Factory
      Method)
    • 【白话设计形式六】抽象工厂格局(Abstract
      Factory)
    • 【白话设计情势七】策略格局(Strategy)
    • 【白话设计形式八】命令情势(Command)
    • 【白话设计格局九】桥接情势(Bridge)
    • 【白话设计格局十】装饰情势(Decorator)
    • 【白话设计形式十一】生成器形式(Builder)
    • 【白话设计形式十二】原型格局(Prototype)
    • 【白话设计方式十三】中介者形式(Mediator)
    • 【白话设计方式十四】代理格局(Proxy)
    • 【白话设计格局十五】观望者情势(Observer)
    • 【白话设计情势十六】迭代器方式(Iterator)
    • 【白话设计形式十七】组合格局(Composite)
    • 【白话设计格局十八】模板方法格局(Template
      Method)
    • 【白话设计情势十九】状态方式(State)
    • 【白话设计形式二十】备忘录格局(Memento)
    • 【白话设计形式二十一】享元方式(Flyweight)
    • 【白话设计形式二十二】解释器形式(Interpreter)
    • 【白话设计形式二十三】义务链情势(Chain of
      Responsibility)
    • 【白话设计方式二十四】访问者情势(Visitor)
    • 【白话设计情势二十五】临别总括:设计形式与7大标准

发表评论

电子邮件地址不会被公开。 必填项已用*标注