ZLMediaKit源码分析 - NotifyCenter_zlmediakit源码解析(1)，Golang中级工程师面试题

机器学习之心AI
77 阅读3分钟 
        funType \*obj = (funType \*) ptr;
        delete obj;
    });
    std::lock_guard<std::recursive_mutex> lck(_mtxListener);
    _mapListener.emplace(tag, pListener);
}




## 事件分发


emitEvent也是调用getDispatcher，然后找到EventDispatcher执行emitEvent

template<typename ...ArgsType> int emitEvent(const std::string &strEvent, ArgsType &&...args) { auto dispatcher = getDispatcher(strEvent); if (!dispatcher) { //该事件无人监听 return 0; } return dispatcher->emitEvent(std::forward(args)...); }


EventDispatcher的emitEvent函数如下

template<typename ...ArgsType> int emitEvent(ArgsType &&...args) { using funType = std::function<void(decltype(std::forward(args))...)>; decltype(_mapListener) copy; { //先拷贝(开销比较小)，目的是防止在触发回调时还是上锁状态从而导致交叉互锁 std::lock_guardstd::recursive_mutex lck(_mtxListener); copy = _mapListener; }

    int ret = 0;
    // 遍历
    for (auto &pr : copy) {
        funType \*obj = (funType \*) (pr.second.get());
        try {
            //执行
            (\*obj)(std::forward<ArgsType>(args)...);
            ++ret;
        } catch (InterruptException &) {
            ++ret;
            break;
        }
    }
    return ret;
}



## 总结


1. NoticeCenter实现了全局的事件分发器，我们可以学习其实现应用到我们项目中解耦类似的场景。
2. 如果处理函数没有做异步处理，那么他归属的线程在触发事件里，就是在emitEvent时的线程，而不是在调用者所在的线程，


## 完整源码及测试


function\_traits.h

#ifndef SRC_UTIL_FUNCTION_TRAITS_H_ #define SRC_UTIL_FUNCTION_TRAITS_H_

#include

namespace toolkit {

template struct function_traits;

//普通函数 template<typename Ret, typename... Args> struct function_traits<Ret(Args...)> { public: enum { arity = sizeof...(Args) }; typedef Ret function_type(Args...); typedef Ret return_type; using stl_function_type = std::function<function_type>; typedef Ret(*pointer)(Args...);

template<size_t I>
struct args
{
    static\_assert(I < arity, "index is out of range, index must less than sizeof Args");
    using type = typename std::tuple_element<I, std::tuple<Args...> >::type;
};

};

//函数指针 template<typename Ret, typename... Args> struct function_traits<Ret(*)(Args...)> : function_traits<Ret(Args...)>{};

//std::function template <typename Ret, typename... Args> struct function_traits<std::function<Ret(Args...)>> : function_traits<Ret(Args...)>{};

//member function #define FUNCTION_TRAITS(...)
template <typename ReturnType, typename ClassType, typename... Args>
struct function_traits<ReturnType(ClassType::*)(Args...) __VA_ARGS__> : function_traits<ReturnType(Args...)>{}; \

FUNCTION_TRAITS() FUNCTION_TRAITS(const) FUNCTION_TRAITS(volatile) FUNCTION_TRAITS(const volatile)

//函数对象 template struct function_traits : function_traits<decltype(&Callable::operator())>{};

} /* namespace toolkit */

#endif /* SRC_UTIL_FUNCTION_TRAITS_H_ */


NoticeCenter.h

/* * Copyright (c) 2016 The ZLToolKit project authors. All Rights Reserved. * * This file is part of ZLToolKit(github.com/ZLMediaKit/…). * * Use of this source code is governed by MIT license that can be found in the * LICENSE file in the root of the source tree. All contributing project authors * may be found in the AUTHORS file in the root of the source tree. */

#ifndef SRC_UTIL_NOTICECENTER_H_ #define SRC_UTIL_NOTICECENTER_H_

#include #include #include #include #include #include <unordered_map> #include "function_traits.h"

namespace toolkit {

class EventDispatcher { public: friend class NoticeCenter; using Ptr = std::shared_ptr;

~EventDispatcher() = default;

private: using MapType = std::unordered_multimap<void *, std::shared_ptr >;

EventDispatcher() = default;

class InterruptException : public std::runtime\_error {
public:
    InterruptException() : std::runtime\_error("InterruptException") {}

    ~InterruptException() {}
};

template<typename ...ArgsType>
int emitEvent(ArgsType &&...args) {
    using funType = std::function<void(decltype(std::forward<ArgsType>(args))...)>;
    decltype(_mapListener) copy;
    {
        //先拷贝(开销比较小)，目的是防止在触发回调时还是上锁状态从而导致交叉互锁
        std::lock_guard<std::recursive_mutex> lck(_mtxListener);
        copy = _mapListener;
    }

    int ret = 0;
    for (auto &pr : copy) {
        funType \*obj = (funType \*) (pr.second.get());
        try {
            (\*obj)(std::forward<ArgsType>(args)...);
            ++ret;
        } catch (InterruptException &) {
            ++ret;
            break;
        }
    }
    return ret;
}

template<typename FUNC>
void addListener(void \*tag, FUNC &&func) {
    using funType = typename function\_traits<typename std::remove_reference<FUNC>::type>::stl_function_type;
    std::shared_ptr<void> pListener(new funType(std::forward<FUNC>(func)), [](void \*ptr) {
        funType \*obj = (funType \*) ptr;
        delete obj;
    });
    std::lock_guard<std::recursive_mutex> lck(_mtxListener);
    _mapListener.emplace(tag, pListener);
}

void delListener(void \*tag, bool &empty) {
    std::lock_guard<std::recursive_mutex> lck(_mtxListener);
    _mapListener.erase(tag);
    empty = _mapListener.empty();
}

private: std::recursive_mutex _mtxListener; MapType _mapListener; };

class NoticeCenter : public std::enable_shared_from_this { public: using Ptr = std::shared_ptr;

static NoticeCenter &Instance();

template<typename ...ArgsType>
int emitEvent(const std::string &strEvent, ArgsType &&...args) {
    auto dispatcher = getDispatcher(strEvent);
    if (!dispatcher) {
        //该事件无人监听
        return 0;
    }
    return dispatcher->emitEvent(std::forward<ArgsType>(args)...);
}

template<typename FUNC>
void addListener(void \*tag, const std::string &event, FUNC &&func) {
    getDispatcher(event, true)->addListener(tag, std::forward<FUNC>(func));
}

void delListener(void \*tag, const std::string &event) {
    auto dispatcher = getDispatcher(event);
    if (!dispatcher) {
        //不存在该事件
        return;
    }
    bool empty;
    dispatcher->delListener(tag, empty);
    if (empty) {
        delDispatcher(event, dispatcher);
    }
}

//这个方法性能比较差
void delListener(void \*tag) {
    std::lock_guard<std::recursive_mutex> lck(_mtxListener);
    bool empty;
    for (auto it = _mapListener.begin(); it != _mapListener.end();) {
        it->second->delListener(tag, empty);
        if (empty) {
            it = _mapListener.erase(it);
            continue;
        }
        ++it;
    }
}

void clearAll() {
    std::lock_guard<std::recursive_mutex> lck(_mtxListener);
    _mapListener.clear();
}

private: EventDispatcher::Ptr getDispatcher(const std::string &event, bool create = false) { std::lock_guardstd::recursive_mutex lck(_mtxListener); auto it = _mapListener.find(event); if (it != _mapListener.end()) { return it->second; } if (create) {

img img img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

avatar
文章
阅读
粉丝