观察者模式

面向过程的思路

创建被观察者对象和观察者对象，创建一个后台线程一直处于运行状态，一旦发现被观察者活动就触发观察者事件。这是真实世界的面向过程思维，功能可以实现，但是效率低下。后台的死循环监听线程会导致cpu飙升，另外不利于添加监听事件，不利于添加新的观察者。
在面向对象编程中使用类聚集的方式主动通知，实现观察者和被观察者的关系。将观察者聚类到被观察的类之中，让被观察者在状态变化后可以通知所有的观察者。

观察者模式

观察者模式的定义

观察者模式(Observer Pattern)，也叫订阅发布模式(Publish/Subscribe)。定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。

观察者模式的结构

Subject 被观察者

定义被观察者必须实现的职责，它必须能够动态地增加、取消观察者。实现的职责：管理观察者并通知观察者。

class Subject(object):
    def __init__(self):
        self._observers = []

    def attach(self, observer):
    """增加观察者"""
        if not observer in self._observers:
            self._observers.append(observer)

    def detach(self, observer):
    """取消观察者"""
        try:
            self._observers.remove(observer)
        except ValueError:
            pass

    def notify(self, modifier=None):
    """通知观察者"""
        for observer in self._observers:
            if modifier != observer:
                observer.update(self)

Observer 观察者

观察者接收到消息后，即进行update操作，对接收到的信息进行处理

class Observer:
    def update(self, subject):
        print('DecimalViewer: Subject %s has data %d' %
              (subject.name, subject.data))

ConcreteSubject 具体的被观察者

定义具体的被观察者自己的业务逻辑，同时定义对哪些事件进行通知

class ConcreteSubject(Subject):
"""继承被观察者类定义具体的被观察者自己的业务"""
    def __init__(self, name=''):
        Subject.__init__(self)
        self.name = name
        self._data = 0

    @property
    def data(self):
        return self._data

    @data.setter
    def data(self, value):
        self._data = value
        self.notify()

ConcreteObserver 具体的观察者

每个观察者在接收到消息后的处理反应不同，各个观察者有自己的处理逻辑。

完整示例代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Created by Vin on 2018/2/8
import time
import random
import threading

keep_keep = []


# 被观察者
class MonkeyKingdom(object):
    def __init__(self):
        self._clients = {}

    def attach(self, client):
        if client not in self._clients:
            self._clients[client.name] = client

    def detach(self, client):
        try:
            del self._clients[client.name]
        except KeyError:
            pass

    def notify(self, worker=None):
        for client in self._clients.values():
            if not client.check_client_status():
                self.detach(client)
            if worker == client.name:
                client.update()


# 观察者
class Monkey(object):
    def __init__(self, client):
        self.name = client
        self.limit = 100
        self.good_to_work = True

    def check_client_status(self):
        ok = True
        if not self.good_to_work:
            ok = False
        if not self.name:
            ok = False
        if not self.limit > 0:
            ok = False
        self.good_to_work = ok
        return ok

    def update(self):
        ok = self.check_client_status()
        if not ok:
            return ok
        time.sleep(random.randint(3, 5))
        self.limit -= 1
        keep_keep.append([self.name, self.limit])
        return ok


# 被观察者自身的活动
class Monkeys(MonkeyKingdom):
    def __init__(self, client=None):
        super(Monkeys, self).__init__()
        self._working = set()
        self.client_all_down = False

    def find_good_to_work(self, client):
        if client in self._clients and client not in self._working:
            worker = client
        else:
            worker = None
            for client in self._clients.keys():
                if client not in self._working:
                    worker = client
                    break
        if worker:
            self._working.add(worker)
            self.notify(worker)
            self._working.remove(worker)
        elif self.check_monkeys_all_down():
            print("客户端已经使用完当天的用量！")
        else:
            print("工作队列已满，请等待！")

    def check_monkeys_all_down(self):
        if not len(self._clients):
            self.client_all_down = True


monkey_team = Monkeys()


def job(client):
    monkey_team.find_good_to_work(client)
    time.sleep(random.randint(3, 5))


def main():
    clients = ['a', 'b', 'c', 'd', 'e']
    for client in clients:
        monkey_team.attach(Monkey(client))
    for client in monkey_team._clients.values():
        print client.name, client.limit
    tl = []
    while True:
        for client in clients:
            print "{0} working".format(client)
            t = threading.Thread(target=job, args=(client,))
            t.start()
            tl.append(t)
        if len(tl) >= 20:
            for t in tl:
                t.join()
            tl = []
        if monkey_team.client_all_down:
            break
    for t in tl:
        t.join()
    print keep_keep


if __name__ == '__main__':
    main()

观察者模式的优点

• 观察者和被观察者之间的抽象耦合，无论时增加观察者还是被观察者都非常容易拓展。
• 建立一套触发机制，观察者模式可以完美实现一系列的触发链

最佳实践

比如你到ATM取钱，多次输错密码，卡会被ATM吞掉，吞卡动作发生时，会触发事件。

1. 摄像头连续快拍
2. 通知监控系统，吞卡
3. 初始化ATM屏幕，返回初始状态

一般前面两个动作有观察者模式完成，后一个动作由异常完成。

观察者模式的缺点

观察者模式需要考虑开发效率和运行效率，一个被观察者，多个观察者，如果出现一个观察者卡壳可能会影响整体的执行效率，这时采用异步的方式。

赏

谢谢你请我喝咖啡

支付宝

微信