用OpenThread现实多线程开发三大设计模式

已于 2023-07-20 17:14:44 修改
阅读量582 收藏 4
点赞数
分类专栏： OpenLinyou C++ 服务器开发 文章标签： c++
于 2023-03-08 21:43:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linyouhappy/article/details/129412403
版权

OpenThread

OpenThread是最舒心的跨平台多线程并发库，多线程三大设计模式: Await模式, Factory模式和Actor模式。

使用优雅的方式，创建线程、管理线程和线程间通信，从而实现多核并发。

OpenThread无任何依赖，全平台设计，只有两个源文件，让小白都可以轻松玩转C++多线程开发。
https://github.com/OpenMiniServer

跨平台支持

Windows、linux、Mac、iOS、Android等跨平台设计

多线程开发三大设计模式

  1. Await模式。两条线程，一条线程向另一条线程请求，同时阻塞等待；另一条线程接收到请求，返回数据唤醒第一条线程；第一条线程唤醒，拿到数据继续执行。
  2. Worker模式。适合客户端，创建一定量的worker线程，组成factory，向外提供唯一接口服务。
  3. Actor模式。适合服务端，一条线程一条Actor，不同的Actor负责不同的功能。

1.Await模式

在主线程创建OpenSyncReturn对象，把它发给子线程，并阻塞等待子线程返回。
子线程接到该消息后，再发消息唤醒，再发OpenSync对象给主线程，等待主线程响应。
主线程线程被唤醒后，收到子线程消息携带的OpenSync对象，唤醒子线程。

#include <assert.h>
#include <iostream>
#include <stdio.h>
#include "openthread.h"

using namespace open;

// Test1
struct TestData
{
    std::string data_;
};
struct Test1Data
{
    std::string data_;
    OpenSync openSync_;
    ~Test1Data()
    {
        printf("Test1:~Test1Data\n");
    }
};

// 子线程调用
void Test1Thread(OpenThreadMsg& msg)
{
    //线程启动的消息
    if (msg.state_ == OpenThread::START)
    {
        printf("Test1Thread[%s] START\n", msg.name().c_str());
        OpenThread::Sleep(1000);
    }
    //线程接收到的消息
    else if (msg.state_ == OpenThread::RUN)
    {
        // //接收主线程的OpenSyncReturn对象，对其唤醒并发消息。
        OpenSyncReturn<TestData, Test1Data>* data = msg.edit<OpenSyncReturn<TestData, Test1Data>>();
        if (data)
        {
            std::shared_ptr<TestData> str = data->get();
            if (str)
            {
                assert(str->data_ == "Waiting for you!");
            }
            auto sptr = std::shared_ptr<Test1Data>(new Test1Data);
            sptr->data_.assign("Of Course,I Still Love You!");
            data->wakeup(sptr);

            //等待主线程唤醒
            sptr->openSync_.await();
        }
        OpenThread::Sleep(1000);
    }
    //线程退出前的消息
    else if (msg.state_ == OpenThread::STOP)
    {
        printf("Test1Thread[%s] STOP\n", msg.name().c_str());
        OpenThread::Sleep(1000);
    }
}

int main()
{
    // 指定线程名，并创建。未填函数，线程未启动状态，需要执行start启动
    auto threadRef = OpenThread::Create("Test1Thread");
    threadRef.start(Test1Thread);

    // 给子线程发送消息
    auto msg = std::shared_ptr<OpenSyncReturn<TestData, Test1Data>>(new OpenSyncReturn<TestData, Test1Data>);
    {
        auto data = std::shared_ptr<TestData>(new TestData);
        data->data_ = "Waiting for you!";
        msg->put(data);
    }
    threadRef.send(msg);
    //阻塞主线程，等待子线程唤醒
    auto ret = msg->awaitReturn();
    if (ret)
    {
        assert(ret->data_ == "Of Course,I Still Love You!");
        printf("Test1====>>:%s\n", ret->data_.c_str());

        //唤醒子线程的阻塞
        ret->openSync_.wakeup();
    }
    // 向子线程发送关闭消息
    threadRef.stop();

    // 等待全部线程退出
    OpenThread::ThreadJoin(threadRef);
    printf("Pause\n");
    return getchar();
}

2.Worker设计模式

适合客户端，创建一定量的worker线程，组成factory，向外提供唯一接口服务。

#include <assert.h>
#include <iostream>
#include <stdio.h>
#include <vector>
#include "openthread.h"
using namespace open;
//业务数据结构
struct Product
{
    int id_;
    std::string goods_;
    Product():id_(0) {}
};

//OpenThread交换协议
struct ProtoTask : public OpenThreadProto
{
    std::shared_ptr<Product> data_;
    OpenSync openSync_;

    static inline int ProtoType() { return 1; }
    virtual inline int protoType() const { return ProtoTask::ProtoType(); }
};

class Worker : public OpenThreadWorker
{   
    //Worker工程线程Factory，提供4个worker线程。
    class Factory
    {
        const std::vector<Worker*> vectWorker_;
    public:
        Factory()
        :vectWorker_({
            new Worker("Producer1"),
            new Worker("Producer2"),
            new Worker("Producer3"),
            new Worker("Producer4"),
            }) {}
        Worker* getWorker()
        {
            if (vectWorker_.empty()) return 0;
            return vectWorker_[std::rand() % vectWorker_.size()];
        }
    };
    static Factory Instance_;

    // Worker
    Worker(const std::string& name)
        :OpenThreadWorker(name)
    {
        mapHandle_[ProtoTask::ProtoType()] = (OpenThreadHandle)&Worker::makeProduct;
        uid_ = 1;
        start();
    }
    ~Worker()
    {
        for (size_t i = 0; i < vectTask_.size(); ++i)
        {
            vectTask_[i].openSync_.wakeup();
        }
    }
    //生产产品
    void makeProduct(const ProtoTask& proto)
    {
        vectTask_.push_back(proto);
        if (rand() % 2 == 0)
        {
            OpenThread::Sleep(1000);
        }
        for (size_t i = 0; i < vectTask_.size(); ++i)
        {
            auto& task = vectTask_[i];
            if (task.data_)
            {
                task.data_->id_ = pid_ + 100 * uid_++;
                task.data_->goods_ = name_ + " Dog coin" + std::to_string(task.data_->id_);
            }
            task.openSync_.wakeup();
        }
        vectTask_.clear();
    }
    int uid_;
    std::vector<ProtoTask> vectTask_;
public:
    //对外服务统一接口
    static bool MakeProduct(std::shared_ptr<Product>& product)
    {
        auto worker = Instance_.getWorker();
        if (!worker)  return false;
        auto proto = std::shared_ptr<ProtoTask>(new ProtoTask);
        proto->data_ = product;
        bool ret = worker->send(-1, proto);
        assert(ret);
        proto->openSync_.await();
        return ret;
    }
};
Worker::Factory Worker::Instance_;

void TestThread(OpenThreadMsg& msg)
{
    if (msg.state_ == OpenThread::START)
    {
        for (size_t i = 0; i < 100; i++)
        {
            auto product = std::shared_ptr<Product>(new Product());
            Worker::MakeProduct(product);
            printf("[%s] Recevie Product:%s\n", msg.name().c_str(), product->goods_.c_str());
        }
        msg.thread().stop();
    }
}

int main()
{
    //创建4条测试线程
    OpenThread::Create("TestThread1", TestThread);
    OpenThread::Create("TestThread2", TestThread);
    OpenThread::Create("TestThread3", TestThread);
    OpenThread::Create("TestThread4", TestThread);
    
    // wait stop
    OpenThread::ThreadJoinAll();
    printf("Pause\n");
    return getchar();
}

3.Actor设计模式

Actor模式。适合服务端，一条线程一条Actor，不同的Actor负责不同的功能。
用Worker类封装使用OpenThread，一条线程一个Worker业务。Inspector(监控)、Timer(定时器)和Server(服务器)继承Worker。
Inspector负责监控多个Timer运行信息，做负载均衡。
Timer提供定时器服务，启动时，向Inspector注册，并提供运行信息。
Server向Inspector查询可用的Timer，然后向此Timer请求定时服务。

#include <assert.h>
#include <iostream>
#include <stdio.h>
#include <map>
#include <unordered_map>
#include "openthread.h"
using namespace open;

class ProtoBuffer : public OpenThreadProto
{
    void* data_;
public:
    int dataType_;
    ProtoBuffer() 
        : OpenThreadProto()
        ,dataType_(0)
        ,data_(0){}
    virtual ~ProtoBuffer() { if (data_) delete data_; }
    template <class T>
    inline T& data() 
    { 
        T* t = 0;
        if (data_)
        {
            t = dynamic_cast<T*>((T*)data_);
            if (data_ == t) return *t;
            delete data_;
        }
        t = new T;
        data_ = t;
        return *t;
    }
    template <class T>
    inline T& data() const
    {
        if (data_)
        {
            T* t = dynamic_cast<T*>((T*)data_);
            if (data_ == t) return *t;
        }
        assert(false);
        static T t;
        return t;
    }
    static inline int ProtoType() { return (int)(uintptr_t) & (ProtoType); }
    virtual inline int protoType() const { return ProtoBuffer::ProtoType(); }
};

struct ProtoLoop : public OpenThreadProto
{
    int type_;
    ProtoLoop() :type_(-1) {}
    static inline int ProtoType() { return (int)(uintptr_t) & (ProtoType); }
    virtual inline int protoType() const { return ProtoLoop::ProtoType(); }
};

struct TimerEventMsg
{
    int workerId_;
    int64_t deadline_;
    TimerEventMsg() : workerId_(0), deadline_(0) {}
};

struct TimerInfoMsg
{
    int workerId_;
    size_t leftCount_;
    int64_t cpuCost_;
    int64_t dataTime_;
    TimerInfoMsg() : workerId_(0), leftCount_(0), cpuCost_(0), dataTime_(0) {}
};

enum EMsgId
{
    query_timer_info,
    get_timer_info,
    request_timer,
};

class Inspector : public OpenThreadWorker
{
    std::unordered_map<std::string, TimerInfoMsg> mapTimerInfo_;
    std::vector<int> vectQueryId;
public:
    Inspector(const std::string& name):OpenThreadWorker(name)
    {
        registers(ProtoLoop::ProtoType(), (OpenThreadHandle)&Inspector::onProtoLoop);
        registers(ProtoBuffer::ProtoType(), (OpenThreadHandle)&Inspector::onProtoBuffer);
    }
    virtual void onStart() {}
private:
    void onProtoLoop(const ProtoLoop& proto)
    {
        printf("Inspector::onProtoLoop[%s]Recevie<<==[%s]\n", name_.c_str(), proto.srcName_.c_str());
        std::vector<int> vectPid;
        vectPid.reserve(mapTimerInfo_.size());
        for (auto iter = mapTimerInfo_.begin(); iter != mapTimerInfo_.end(); iter++)
        {
            if (iter->second.workerId_ >= 0)
                vectPid.push_back(iter->second.workerId_);
        }
        auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
        root->dataType_ = get_timer_info;
        send(vectPid, root);
    }
    void onProtoBuffer(const ProtoBuffer& proto)
    {
        printf("Inspector::onProtoBuffer[%s]Recevie<<==[%s]\n", name_.c_str(), proto.srcName_.c_str());
        if (proto.dataType_ == get_timer_info)
        {
            auto& msg = proto.data<TimerInfoMsg>();
            auto& timerInfo = mapTimerInfo_[proto.srcName_];
            timerInfo = msg;
            if (!vectQueryId.empty())
            {
                auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
                root->dataType_ = query_timer_info;
                auto& info = root->data<TimerInfoMsg>();
                info = timerInfo;
                send(vectQueryId, root);

                vectQueryId.clear();
            }
        }
        else if (proto.dataType_ == query_timer_info)
        {
            TimerInfoMsg* tmpInfo = 0;
            auto curTime = OpenThread::MilliUnixtime();
            for (auto iter = mapTimerInfo_.begin(); iter != mapTimerInfo_.end(); iter++)
            {
                auto& info = iter->second;
                if (curTime > info.dataTime_ + 10000) continue;
                if (tmpInfo)
                {
                    if (tmpInfo->leftCount_ > info.leftCount_ || tmpInfo->cpuCost_ > info.cpuCost_)
                        tmpInfo = &info;
                }
                else
                {
                    tmpInfo = &info;
                }
            }
            if (!tmpInfo)
            {
                vectQueryId.push_back(proto.srcPid_);
                auto root = std::shared_ptr<ProtoLoop>(new ProtoLoop);
                sendLoop(root);
            }
            else
            {
                auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
                root->dataType_ = query_timer_info;
                auto& info = root->data<TimerInfoMsg>();
                info = *tmpInfo;
                send(proto.srcPid_, root);
            }
        }
    }
};


class Timer:public OpenThreadWorker
{
    int inspectorId_;
    std::multimap<int64_t, int> mapTimerEvent_;
public:
    Timer(const std::string& name):OpenThreadWorker(name)
    {
        inspectorId_ = -1;
        registers(ProtoLoop::ProtoType(), (OpenThreadHandle)&Timer::onProtoLoop);
        registers(ProtoBuffer::ProtoType(), (OpenThreadHandle)&Timer::onProtoBuffer);
    }
protected:
    virtual void onStart()
    {
        while (inspectorId_ < 0)
        {
            inspectorId_ = ThreadId("Inspector");
            if (inspectorId_ >= 0)
            {
                auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
                root->dataType_ = get_timer_info;
                auto& msg = root->data<TimerInfoMsg>();
                msg.workerId_ = pid();
                msg.dataTime_ = OpenThread::MilliUnixtime();
                msg.cpuCost_ = thread_->cpuCost();
                msg.leftCount_ = thread_->leftCount();

                send(inspectorId_, root);
                break;
            }
            OpenThread::Sleep(100);
        }
        auto root = std::shared_ptr<ProtoLoop>(new ProtoLoop);
        sendLoop(root);
    }
private:
    void onProtoLoop(const ProtoLoop& proto)
    {
        printf("Timer::onProtoLoop[%s]Recevie<<==[%s]\n", name_.c_str(), proto.srcName_.c_str());
        assert(proto.srcPid_ == pid_);
        int64_t curTime = 0;
        while (canLoop())
        {
            if (!mapTimerEvent_.empty())
            {
                curTime = OpenThread::MilliUnixtime();
                while (!mapTimerEvent_.empty())
                {
                    auto iter = mapTimerEvent_.begin();
                    if (curTime > iter->first)
                    {
                        auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
                        root->dataType_ = request_timer;
                        auto& msg = root->data<TimerEventMsg>();
                        msg.workerId_ = pid();
                        msg.deadline_ = curTime;

                        send(iter->second, root);

                        mapTimerEvent_.erase(iter);
                    }
                    else
                    {
                        break;
                    }
                }
            }
            OpenThread::Sleep(10);
        }
    }
    void onProtoBuffer(const ProtoBuffer& proto)
    {
        printf("Timer::onProtoBuffer[%s]Recevie<<==[%s]\n", name_.c_str(), proto.srcName_.c_str());
        if (proto.dataType_ == get_timer_info)
        {
            auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
            root->dataType_ = get_timer_info;
            auto& msg = root->data<TimerInfoMsg>();
            msg.workerId_ = pid();
            msg.dataTime_  = OpenThread::MilliUnixtime();
            msg.cpuCost_   = thread_->cpuCost();
            msg.leftCount_ = thread_->leftCount();
            send(proto.srcPid_, root);

            auto sptr = std::shared_ptr<ProtoLoop>(new ProtoLoop);
            sendLoop(sptr);
        }
        else if (proto.dataType_ == request_timer)
        {
            auto& msg = proto.data<TimerEventMsg>();
            mapTimerEvent_.insert({ msg.deadline_, proto.srcPid_ });

            auto sptr = std::shared_ptr<ProtoLoop>(new ProtoLoop);
            sendLoop(sptr);
        }
    }
};

class Server:public OpenThreadWorker
{
    int inspectorId_;
    int collect_;
public:
    Server(const std::string& name)
        :OpenThreadWorker(name)
        ,inspectorId_(-1)
    {
        collect_ = 0;
        registers(ProtoLoop::ProtoType(), (OpenThreadHandle)&Server::onProtoLoop);
        registers(ProtoBuffer::ProtoType(), (OpenThreadHandle)&Server::onProtoBuffer);
    }
protected:
    virtual void onStart()
    {
        while (inspectorId_ < 0)
        {
            inspectorId_ = ThreadId("Inspector");
            OpenThread::Sleep(10);
        }
        auto sptr = std::shared_ptr<ProtoLoop>(new ProtoLoop);
        sendLoop(sptr);
    }
private:
    void onProtoLoop(const ProtoLoop& proto)
    {
        printf("Server::onProtoLoop[%s]Recevie<<==[%s]\n", name_.c_str(), proto.srcName_.c_str());
        auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
        root->dataType_ = query_timer_info;
        send(inspectorId_, root);
    }

    void onProtoBuffer(const ProtoBuffer& proto)
    {
        printf("Server::onProtoBuffer[%s]Recevie<<==[%s]\n", name_.c_str(), proto.srcName_.c_str());
        if (proto.dataType_ == query_timer_info)
        {
            auto& msg = proto.data<TimerInfoMsg>();
            if (msg.workerId_ > 0)
            {
                auto root = std::shared_ptr<ProtoBuffer>(new ProtoBuffer);
                root->dataType_ = request_timer;
                auto& event = root->data<TimerEventMsg>();
                int64_t curTime = OpenThread::MilliUnixtime();
                event.deadline_ = curTime + curTime % 2000;
                if (event.deadline_ > curTime + 2000)
                {
                    event.deadline_ = curTime;
                }
                send(msg.workerId_, root);
            }
            else
            {
                auto sptr = std::shared_ptr<ProtoLoop>(new ProtoLoop);
                sendLoop(sptr);
            }
        }
        else if (proto.dataType_ == request_timer)
        {
            if (collect_++ > 100)
            {
                OpenThread::StopAll();
                return;
            }
            sendLoop(std::shared_ptr<ProtoLoop>(new ProtoLoop));
        }
    }
};

int main()
{
    OpenThread::StopAll();
    std::vector<OpenThreadWorker*> vectWorker =
    {
        new Inspector("Inspector"),
        new Timer("timer1"),
        new Timer("timer2"),
        new Server("server1"),
        new Server("server2"),
        new Server("server3"),
        new Server("server4")
    };
    for (size_t i = 0; i < vectWorker.size(); i++)
    {
        vectWorker[i]->start();
    }

    OpenThread::ThreadJoinAll();
    for (size_t i = 0; i < vectWorker.size(); i++)
    {
        delete vectWorker[i];
    }
    vectWorker.clear();
    printf("Pause\n");
    return getchar();
}

编译和执行

请安装cmake工具，用cmake构建工程，可以在vs或者xcode上编译运行。
源代码：https://github.com/OpenMiniServer/openthread

#克隆项目
git clone https://github.com/OpenMiniServer/openthread
cd ./openthread
#创建build工程目录
mkdir build
cd build
cmake ..
#如果是win32，在该目录出现openthread.sln，点击它就可以启动vs写代码调试
make
./helloworld

全部源文件

  • src/openthread.h
  • src/openthread.cpp

技术特点

OpenThread的技术特点：

  1. 跨平台设计，提供Linux统一的pthread接口，支持安卓和iOS。
  2. 线程池管理采用智能指针和无锁map，实现高效访问线程对象。
  3. 每个线程自带消息队列，消息放入队列原子锁，而读取消息队列，无锁操作。保证线程交换信息高效。
  4. 线程交互数据，采用智能指针管理，实现内存自动化管理，无需担忧内存泄漏。
  5. 多线程三大设计模式: Await模式, Worker模式和Actor模式。
OpenMiniServer
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
openthread：Google发布的OpenThread是Thread网络协议的开源实现
02-04
什么是OpenThread？ Google发布的OpenThread是... 网络协议的开源实现。 Google Nest已发布OpenThread，以使开发人员可以更广泛地使用Nest产品中使用的技术，从而加快互联家庭产品的开发速度。 ...与操作系统和平台无关的平台狭窄的平台抽象层和较小的内存占用空间，使其具有高度的可移植性。 它支持片上系统（SoC）和网络协处理器（NCP）设计。 ...一个线程认证组件，实现了定义的所有功能，包括所有线程网络层（IPv6、6LoWPAN，具有MAC安全性的IEEE 802.15.4，网格链接建立，网格路由）和设备角色，以及支持。 有关Thre
OpenThread is an Open Source Implementation of Thread IoT Networking Protocol
闲云孤鹤
05-14 1338
本文转载至：http://www.cnx-software.com/2016/05/12/openthread-is-an-open-source-implementation-of-thread-iot-networking-protocol/ Thread was announced about two years ago, as a new IP-based wireless prot
OpenThread种种
Sting的专栏 - Under the hood
08-28 9057
我在Windows NT系统（包括2K和XP）和Windows CE系统各写有一个工具，专门用来研究系统的运行时状态，比如进程、线程的各种信息，哪些DLL被哪些进程加载了，等等。如果某天突然想到一些好玩的东西，我也会把它加到工具里，比如，下图的这个，在系统登陆、锁定界面上运行了一个计算器。一般情况下，我比较喜欢做的事是观察线程的Call Stack。这就要用到一个关键的API：OpenThread
vc6 OpenThread
谢绝留言与私信
03-20 1200
前言 vc6中没有OpenThread的头文件定义, 需要动态加载API. vc6英文企业版自带的msdn对OpenThread没有说明，在msdn中搜索到的OpenThread片段的说明连参数都说错了, 需要装一个[MSDN].msdn_oct_2001.iso demo// OpenThread() is exported by KERNEL32.DLL, but is not inclu
OpenThread的用法
nishuodeqianshou的专栏
07-23 4613
typedef HANDLE (WINAPI *_OPENTHREAD)(DWORD,BOOL,DWORD); _OPENTHREAD OpenThread=(_OPENTHREAD)GetProcAddress(GetModuleHandle(_T("Kernel32.dll")),"OpenThread"); OpenThread(NULL,FALSE,ThreadId);
OpenThreads库介绍——Thread
Frank的专栏
03-15 6682
OpenThreads库是一个轻量级的跨平台多线程库，在2.x之前是独立发展的一个库，在2.x后并入到OSG的源码中，OSG中大量的多线程操作都是基于这个库编写的。（事实上使用该库是历史原因的问题，在OSG创立的时候，C++标准中并没有C++11引入的线程库），库的详细介绍参考：OpenThreads站点 Thread线程 线程实现类。它是一个面向对象的线程实现接口，每定义一个Thread...
多线程设计模式——Pipeline(流水线)模式
01-27
Pipeline(流水线)模式有时一些线程的步奏比较冗长，而且由于每个阶段的结果与下阶段的执行有关系，又不能分开。可以将任务的处理分解为若干个处理阶段，上一个阶段任务的结果交给下一个阶段来处理，这样每个线程的...
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案，它们是编程经验的结晶，可以帮助开发者在面临多线程挑战时快速找到...
Java多线程编程实战指南 设计模式篇.rar
03-26
在Java编程中，多线程是一项关键技能，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。设计模式则是解决常见编程问题的模板，通过应用这些模式，开发者可以构建更健壮、可维护的多线程系统。本实战...
ot-br-posix：OpenThread边界路由器，用于基于POSIX平台的线程边界路由器
02-04
OpenThread边界路由器 根据，线程边界路由器将线程网络连接到其他基于IP的网络，例如Wi-Fi或以太网。 线程网络需要边界路由器才能连接到其他网络。 线程边界路由器至少支持以下功能： 通过线程设备和其他外部IP网络之间的路由进行端到端IP连接 外部线程调试（例如，移动电话）以对线程设备进行身份验证并将其加入线程网络 OpenThread的边界路由器的实现称为OpenThread边界路由器（OTBR）。 OTBR是具有Nordic nRF52840 NCP的Raspberry Pi 3B上的线程认证组件。 OTBR包含许多功能，包括： 用于配置和管理的Web UI 线程边界代
ot-rtos：OpenThread RTOS，OpenThread，LwIP和FreeRTOS的集成
02-03
ot-rtos：OpenThread RTOS，OpenThread，LwIP和FreeRTOS的集成
OpenThreads
08-20
osg3.2.1的64位，ot20-OpenThreads，包含debug,realease版的。
【开源库学习】OpenThreads
撬动未来的支点的专栏
05-11 340
项目地址 Github：https://github.com/tibogens/OpenThreads 码云：https://gitee.com/lukeson/OpenThreads 参考资料 网上已经有很多比较好的文章了，这里汇总一下，便于查阅。 OpenThreads库介绍——Condition OpenThreads库介绍——Barrier OpenThreads库介绍——Block OpenThreads库介绍——ReadWriteMutex OpenThreads库介绍——Mutex ..
OpenThreads库的使用-Thread
snail_hunan的专栏
04-09 5990
Thread简介OpenThread库，提供了一个Thread类，供用户创建自己的线程。其使用非常方便，用户只需要继承自OpenThreads::Thread类，然后自己重写run接口即可。Thread程序示例下面程序，使用一个线程，去卖票。g_ticketCounts表示当前可用的票的数量。#include <OpenThreads/Thread> #include <iostream>int g
ESP32-H2 OpenThread example introduction
ESP 技术分享，推动万物互联
09-29 421
In folder esp-idf/examples/openthread, it contains following OpenThread examples: ot_cli is an OpenThread Command Line example, in addition to the features listed in OpenThread CLI, it supports some additional features such as TCP, UDP and Iperf over lwI
OpenThreads库学习
weixin_30905981的博客
07-31 547
在看STM32资料中看到STM32WB系列“双核无线微控制器配备双核无线微控制器(MCU)配备Bluetooth® 5、OpenThread和ZigBee®3.0连接技术，同时兼备超低功耗性能“不知道这个OpenThread是啥东东： OpenThread库：提供了一个Thread类，供用户创建自己的线程。其使用非常方便，用户只需要继承自OpenThreads::Thread类，#in...
20.[个人]C++线程入门到进阶（20）----线程函数：OpenThread
shuimanting520的博客
04-25 1259
待更新
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值