ZLMediaKit/api/source/mk_thread.cpp

110 lines
3.1 KiB
C++
Raw Normal View History

2019-12-27 10:46:40 +08:00
/*
2020-04-04 20:30:09 +08:00
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
2019-12-27 10:46:40 +08:00
*
* This file is part of ZLMediaKit(https://github.com/xiongziliang/ZLMediaKit).
*
2020-04-04 20:30:09 +08:00
* 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.
2019-12-27 10:46:40 +08:00
*/
#include "mk_thread.h"
#include "mk_tcp_private.h"
#include "Util/logger.h"
#include "Poller/EventPoller.h"
2020-05-08 09:52:05 +08:00
#include "Thread/WorkThreadPool.h"
2019-12-27 10:46:40 +08:00
using namespace std;
using namespace toolkit;
API_EXPORT mk_thread API_CALL mk_thread_from_tcp_session(mk_tcp_session ctx){
assert(ctx);
2020-04-26 19:34:58 +08:00
TcpSessionForC *obj = (TcpSessionForC *)ctx;
2019-12-27 10:46:40 +08:00
return obj->getPoller().get();
}
API_EXPORT mk_thread API_CALL mk_thread_from_tcp_client(mk_tcp_client ctx){
assert(ctx);
2020-04-26 19:34:58 +08:00
TcpClientForC::Ptr *client = (TcpClientForC::Ptr *)ctx;
2019-12-27 10:46:40 +08:00
return (*client)->getPoller().get();
}
2020-05-08 09:52:05 +08:00
API_EXPORT mk_thread API_CALL mk_thread_from_pool(){
return EventPollerPool::Instance().getPoller().get();
}
API_EXPORT mk_thread API_CALL mk_thread_from_pool_work(){
return WorkThreadPool::Instance().getPoller().get();
}
2019-12-27 10:46:40 +08:00
API_EXPORT void API_CALL mk_async_do(mk_thread ctx,on_mk_async cb, void *user_data){
assert(ctx && cb);
EventPoller *poller = (EventPoller *)ctx;
poller->async([cb,user_data](){
cb(user_data);
});
}
API_EXPORT void API_CALL mk_sync_do(mk_thread ctx,on_mk_async cb, void *user_data){
assert(ctx && cb);
EventPoller *poller = (EventPoller *)ctx;
poller->sync([cb,user_data](){
cb(user_data);
});
}
2020-04-26 19:34:58 +08:00
class TimerForC : public std::enable_shared_from_this<TimerForC>{
public:
typedef std::shared_ptr<TimerForC> Ptr;
TimerForC(on_mk_timer cb, void *user_data){
_cb = cb;
_user_data = user_data;
}
~TimerForC(){}
uint64_t operator()(){
lock_guard<recursive_mutex> lck(_mxt);
if(!_cb){
return 0;
}
return _cb(_user_data);
}
void cancel(){
lock_guard<recursive_mutex> lck(_mxt);
_cb = nullptr;
_task->cancel();
}
void start(uint64_t ms ,EventPoller &poller){
2020-04-26 19:34:58 +08:00
weak_ptr<TimerForC> weak_self = shared_from_this();
2020-04-26 19:36:17 +08:00
_task = poller.doDelayTask(ms, [weak_self]() {
2020-04-26 19:34:58 +08:00
auto strong_self = weak_self.lock();
2020-04-26 19:36:17 +08:00
if (!strong_self) {
return (uint64_t) 0;
2020-04-26 19:34:58 +08:00
}
return (*strong_self)();
});
}
private:
on_mk_timer _cb = nullptr;
void *_user_data = nullptr;
recursive_mutex _mxt;
DelayTask::Ptr _task;
};
2019-12-27 10:46:40 +08:00
API_EXPORT mk_timer API_CALL mk_timer_create(mk_thread ctx,uint64_t delay_ms,on_mk_timer cb, void *user_data){
assert(ctx && cb);
EventPoller *poller = (EventPoller *)ctx;
2020-04-26 19:34:58 +08:00
TimerForC::Ptr *ret = new TimerForC::Ptr(new TimerForC(cb, user_data));
(*ret)->start(delay_ms,*poller);
return ret;
2019-12-27 10:46:40 +08:00
}
API_EXPORT void API_CALL mk_timer_release(mk_timer ctx){
assert(ctx);
2020-04-26 19:34:58 +08:00
TimerForC::Ptr *obj = (TimerForC::Ptr *)ctx;
2019-12-27 10:46:40 +08:00
(*obj)->cancel();
delete obj;
}