Python 设计模式：工厂模式、单例模式

1. 工厂模式

2. 单例模式

 

 

1. 工厂模式

1.1 初步设计

设计一个卖车的4S店，该怎样做呢？

# 定义车类
class Car:

    # 定义车的方法
    def move(self):
        print("车启动")
        
    def stop(self):
        print("停车")
    
    
# 定义一个销售车的店类
class CarStore:

    def order(self):
        self.car = Car()
        self.car.move()
        self.car.stop()
        

# 进行购车
my_car = CarStore()
my_car.order()

上面的 4s 店，只能销售定义了的一种类型的车。如果这是个销售北京现代品牌的车，比如伊兰特、索纳塔等，该怎样做呢？

设计一个卖北京现代车的4S店

# 定义伊兰特车类
class YilanteCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义索纳塔车类
class SuonataCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义一个销售北京现代车的店类
class CarStore(object):

    def order(self, typeName):
        #根据客户的不同要求，生成不同的类型的车
        if typeName == "伊兰特":
            car = YilanteCar()
        elif typeName == "索纳塔":
            car = SuonataCar()
        return car

这样做不太好，因为当北京现代又生产一种新类型的车时，又得在 CarStore 类中修改，有没有好的解决办法呢？

1.2 简单工厂模式

1）使用函数实现：

# 定义伊兰特车类
class YilanteCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义索纳塔车类
class SuonataCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 用来生成具体的对象
def createCar(typeName):
    if typeName == "伊兰特":
        car = YilanteCar()
    elif typeName == "索纳塔":
        car = SuonataCar()
    return car

# 定义一个销售北京现代车的店类
class CarStore(object):

    def order(self, typeName):
        # 让工厂根据类型，生产一辆汽车
        car = createCar(typeName)
        return car

2）使用类来实现：

# 定义伊兰特车类
class YilanteCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义索纳塔车类
class SuonataCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义一个生产汽车的工厂，让其根据具体的订单生产车
class CarFactory(object):

    def createCar(self, typeName):
        if typeName == "伊兰特":
            car = YilanteCar()
        elif typeName == "索纳塔":
            car = SuonataCar()

        return car

# 定义一个销售北京现代车的店类
class CarStore(object):

    def __init__(self):
        #设置4s店的指定生产汽车的工厂
        self.carFactory = CarFactory()

    def order(self, typeName):
        # 让工厂根据类型，生产一辆汽车
        car = self.carFactory.createCar(typeName)
        return car

咋一看来，好像只是把生产环节重新创建了一个类，这确实比较像是一种编程习惯，此种解决方式被称作简单工厂模式。

工厂函数、工厂类对具体的生成环节进行了封装，这样有利于代码的后需扩展，即把功能划分的更具体，4s店只负责销售，汽车厂只负责制造。

1.3 工厂模式

多种品牌的汽车 4S 店

当买车时，有很多种品牌可以选择，比如北京现代、别克、凯迪拉克、特斯拉等，那么此时该怎样进行设计呢？

把以上代码复制一份显然会有冗余的重复代码，那么可以将汽车店共有的方法放在基类中，而子类负责实现各自不同的部分。

# 所有车都有的基本功能
class Car:

    def __init__(self, name):
        self.name = name

    def start(self):
        print("%s启动了" % self.name)

    def stop(self):
        print("%s停车了" % self.name)


class Suonata(Car):
    pass
class Mingtu(Car):
    pass
class Mini(Car):
    pass
class Smart(Car):
    pass


# 生产现代汽车的工厂
class ModernFactory:

    def createCarByType(self, type):
        if type == '索纳塔':
            return Suonata('索纳塔')
        if type == '明图':
            return Mingtu('明图')


# 生产宝马汽车的工厂
class BMWFactory:

    def createCarByType(self, type):
        if type == 'Mini':
            return Mini('Mini')
        if type == 'Smart':
            return Smart('Smart')


# 4S店 基类
class CarStore:

    # 提供接口，让子类自己根据需要实现
    def select_car(self):
        pass

    def order(self, type):
        return self.select_car(type)
        
    # 4S店更多的公有功能
    # def ...


# 现代汽车4S店
class ModernStore(CarStore):

    def select_car(self, type):
        return ModernFactory().createCarByType(type)


# 宝马汽车4S店
class BmwStore(CarStore):

    def select_car(self, type):
        return BMWFactory().createCarByType(type)



modern_store = ModernStore()
modern_car = model_store.order("索纳塔")
modern_car.start()
modern_car.stop()

bmw_store = BmwStore()
bmw = bmw_store.order("Smart")
bmw.start()
bmw.stop()

• 最后来看看工厂方法模式的定义：定义了一个创建对象的接口（可以理解为函数），由子类决定要实例化的类是哪一个。工厂方法模式让类的实例化推迟到子类，抽象的 CarStore 提供了一个创建对象的方法 select_car，也叫作工厂方法。
• 子类真正实现这个 select_car 方法创建出具体产品。创建者类选择了使用了哪个子类，就决定了实际创建的产品是什么。

 

2. 单例模式

什么是单例模式？确保某一个类只有一个实例，在实例化时自行向整个系统提供这个实例，这个类被称为单例类，单例模式是一种对象创建型模式。

举个常见的单例模式例子，我们日常使用的电脑上都有一个回收站，在整个操作系统中，回收站只能有一个实例，整个系统都使用这个唯一的实例，而且回收站自行提供自己的实例。因此回收站是单例模式的应用。

创建单例，保证只有 1 个对象

class Singleton:

    __instance = None
    
    # 如果__instance没有被赋值过（即为None），
    # 那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
    # 能够知道之前已经创建过对象了，这样就保证了只有1个对象
    # 注意，此处__new__()方法中的age与name既不是类属性也不是实例属性，虽然在创建对象时需要传参，但无实际作用
    def __new__(cls, age, name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance
        

xiaoming = Singleton(18, "xiaoming")
xiaodan = Singleton(18, "xiaodan")
# xiaoming与xiaodan实际为同一个对象
print(id(xiaoming))  # 46105504
print(id(xiaodan))  # 46105504  

xiaoming.age = 19  # 给对象xiaoming添加属性
print(xiaodan.age)  # 19

创建单例，只执行 1 次 __init__() 方法

class Singleton:

    __instance = None
    __first_init = False
    
    def __new__(cls, age, name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance
    
    def __init__(self, age, name):
       # 判断是否第一次执行 init 方法
        if not Singleton.__first_init:
            self.age = age
            self.name = name
            Singleton.__first_init = True
    

xiaoming = Singleton(18, "xiaoming")
xiaodan = Singleton(18, "xiaodan")

print(id(xiaoming))  # 46105504
print(id(xiaodan))  # 46105504

print(xiaoming.age)  # 18
print(xiaodan.age)  # 18

xiaoming.age = 19  # 修改xiaoming对象的实例属性
print(xiaodan.age)  # 19

单例模式的线程安全问题

未加锁版的单例模式，在多线程下，可能会存在线程安全问题，即创建了多个实例。

class Singleton:

    __instance = None
    # 如果__instance没有被赋值过（即为None），
    # 那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
    # 能够知道之前已经创建过对象了，这样就保证了只有1个对象

    def __new__(cls):
        if not cls.__instance:  # 此处有可能发生多个线程同时判断了False，从而各自创建实例对象
            cls.__instance = object.__new__(cls)
        return cls.__instance

改进：DCL（Double Check Lock，双重检查锁）单例模式

此加锁版的单例模式，可以避免线程安全问题。

class Singleton:

    __instance = None
    # 如果__instance没有被赋值过（即为None），
    # 那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
    # 能够知道之前已经创建过对象了，这样就保证了只有1个对象

    def __new__(cls):
        if not cls.__instance:  # 此处的判断，多线程间可各自执行判断，无需争夺锁资源，因此耗时纳秒级别
            lock.acquire():
                if not cls.__instance:  # 如果没有外层的if判断，则每次判断都需要各个线程先争夺锁，耗时在微秒级别
                    cls.__instance = object.__new__(cls)
                    lock.release()
        return cls.__instance