kopie van
https://github.com/tearshark/librf.git
synced 2024-10-04 08:50:31 +08:00
cd74eea532
上传Doxygen生成的文档。
209 regels
4.4 KiB
C++
209 regels
4.4 KiB
C++
#include <chrono>
|
||
#include <iostream>
|
||
#include <string>
|
||
#include <thread>
|
||
#include <deque>
|
||
|
||
#include "librf.h"
|
||
|
||
using namespace resumef;
|
||
using namespace std::chrono;
|
||
|
||
static mutex_t g_lock;
|
||
static intptr_t g_counter = 0;
|
||
|
||
static const size_t N = 10;
|
||
|
||
//🔒-50ms-🔒🗝🗝-150ms-|
|
||
//-------------.........
|
||
static future_t<> test_mutex_pop(size_t idx)
|
||
{
|
||
for (size_t i = 0; i < N / 2; ++i)
|
||
{
|
||
{
|
||
batch_unlock_t _locker = co_await g_lock.lock(); //_locker析构后,会调用对应的unlock()函数。
|
||
|
||
--g_counter;
|
||
std::cout << "pop :" << g_counter << " on " << idx << std::endl;
|
||
|
||
co_await 50ms;
|
||
|
||
batch_unlock_t _locker_2 = co_await g_lock;
|
||
|
||
--g_counter;
|
||
std::cout << "pop :" << g_counter << " on " << idx << std::endl;
|
||
}
|
||
co_await 150ms;
|
||
}
|
||
}
|
||
|
||
//🔒-50ms-🗝-50ms-🔒-50ms-🗝-50ms-|
|
||
//---------........---------.......
|
||
//方法之一
|
||
static future_t<> test_mutex_push(size_t idx)
|
||
{
|
||
for (size_t i = 0; i < N; ++i)
|
||
{
|
||
{
|
||
batch_unlock_t _locker = co_await g_lock.lock();
|
||
|
||
++g_counter;
|
||
std::cout << "push:" << g_counter << " on " << idx << std::endl;
|
||
|
||
co_await 50ms;
|
||
}
|
||
co_await 50ms;
|
||
}
|
||
}
|
||
|
||
static future_t<> test_mutex_try_push(size_t idx)
|
||
{
|
||
for (size_t i = 0; i < N; ++i)
|
||
{
|
||
{
|
||
while (!co_await g_lock.try_lock())
|
||
co_await yield();
|
||
|
||
++g_counter;
|
||
std::cout << "push:" << g_counter << " on " << idx << std::endl;
|
||
|
||
co_await 50ms;
|
||
co_await g_lock.unlock();
|
||
}
|
||
co_await 50ms;
|
||
}
|
||
}
|
||
|
||
static future_t<> test_mutex_timeout_push(size_t idx)
|
||
{
|
||
for (size_t i = 0; i < N; ++i)
|
||
{
|
||
{
|
||
while (!co_await g_lock.try_lock_for(10ms))
|
||
co_await yield();
|
||
|
||
++g_counter;
|
||
std::cout << "push:" << g_counter << " on " << idx << std::endl;
|
||
|
||
co_await 50ms;
|
||
co_await g_lock.unlock();
|
||
}
|
||
co_await 50ms;
|
||
}
|
||
}
|
||
|
||
//🔒-50ms-🗝-50ms-🔒-50ms-🗝-50ms-|
|
||
//---------........---------.......
|
||
static std::thread test_mutex_async_push(size_t idx)
|
||
{
|
||
return std::thread([=]
|
||
{
|
||
char provide_unique_address = 0;
|
||
for (size_t i = 0; i < N; ++i)
|
||
{
|
||
if (g_lock.try_lock_for(500ms, &provide_unique_address))
|
||
{
|
||
batch_unlock_t _locker(std::adopt_lock, &provide_unique_address, g_lock);
|
||
|
||
++g_counter;
|
||
std::cout << "push:" << g_counter << " on " << idx << std::endl;
|
||
std::this_thread::sleep_for(50ms);
|
||
|
||
//g_lock.unlock(&provide_unique_address);
|
||
}
|
||
|
||
std::this_thread::sleep_for(50ms);
|
||
}
|
||
});
|
||
}
|
||
|
||
static void resumable_mutex_synch()
|
||
{
|
||
go test_mutex_timeout_push(0);
|
||
go test_mutex_pop(1);
|
||
|
||
this_scheduler()->run_until_notask();
|
||
|
||
std::cout << "result:" << g_counter << std::endl;
|
||
}
|
||
|
||
static void resumable_mutex_async()
|
||
{
|
||
auto th = test_mutex_async_push(0);
|
||
std::this_thread::sleep_for(25ms);
|
||
go test_mutex_pop(1);
|
||
|
||
this_scheduler()->run_until_notask();
|
||
th.join();
|
||
|
||
std::cout << "result:" << g_counter << std::endl;
|
||
}
|
||
|
||
static future_t<> resumable_mutex_range_push(size_t idx, mutex_t a, mutex_t b, mutex_t c)
|
||
{
|
||
for (int i = 0; i < 10000; ++i)
|
||
{
|
||
batch_unlock_t __lockers = co_await mutex_t::lock(a, b, c);
|
||
assert(a.is_locked());
|
||
assert(b.is_locked());
|
||
assert(c.is_locked());
|
||
|
||
++g_counter;
|
||
//std::cout << "push:" << g_counter << " on " << idx << std::endl;
|
||
|
||
//co_await 5ms;
|
||
}
|
||
}
|
||
|
||
static future_t<> resumable_mutex_range_pop(size_t idx, mutex_t a, mutex_t b, mutex_t c)
|
||
{
|
||
for (int i = 0; i < 10000; ++i)
|
||
{
|
||
co_await mutex_t::lock(adopt_manual_unlock, a, b, c);
|
||
assert(a.is_locked());
|
||
assert(b.is_locked());
|
||
assert(c.is_locked());
|
||
|
||
--g_counter;
|
||
//std::cout << "pop :" << g_counter << " on " << idx << std::endl;
|
||
|
||
//co_await 5ms;
|
||
co_await mutex_t::unlock(a, b, c);
|
||
}
|
||
}
|
||
|
||
static void resumable_mutex_lock_range()
|
||
{
|
||
mutex_t mtxA, mtxB, mtxC;
|
||
|
||
//不同的线程里加锁也需要是线程安全的
|
||
std::thread push_th([&]
|
||
{
|
||
local_scheduler_t __ls__;
|
||
|
||
go resumable_mutex_range_push(10, mtxA, mtxB, mtxC);
|
||
go resumable_mutex_range_push(11, mtxA, mtxC, mtxB);
|
||
|
||
this_scheduler()->run_until_notask();
|
||
});
|
||
|
||
go resumable_mutex_range_pop(12, mtxC, mtxB, mtxA);
|
||
go resumable_mutex_range_pop(13, mtxB, mtxA, mtxC);
|
||
|
||
this_scheduler()->run_until_notask();
|
||
push_th.join();
|
||
|
||
std::cout << "result:" << g_counter << std::endl;
|
||
}
|
||
|
||
void resumable_main_mutex()
|
||
{
|
||
resumable_mutex_synch();
|
||
std::cout << std::endl;
|
||
|
||
resumable_mutex_async();
|
||
std::cout << std::endl;
|
||
|
||
resumable_mutex_lock_range();
|
||
}
|