81b8923b14
Co-authored-by: tushicheng <18829573815@163.com> Co-authored-by: HaHaJeff <jeffzhouhhh@gmail.com> Co-authored-by: dimstars <liangjinrongcm@gmail.com>
125 lines
2.8 KiB
C++
125 lines
2.8 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include "atomic"
|
|
#include "lib/thread/threads.h"
|
|
|
|
using namespace oceanbase::lib;
|
|
|
|
TEST(TestThreads, CanRun)
|
|
{
|
|
int val = 0;
|
|
|
|
val = 0;
|
|
class Thread: public Threads {
|
|
public:
|
|
Thread(int &val) : val_(val) {}
|
|
virtual void run(int64_t idx) override
|
|
{
|
|
val_++;
|
|
}
|
|
int &val_;
|
|
} th(val);
|
|
th.start();
|
|
th.wait();
|
|
ASSERT_EQ(1, val);
|
|
}
|
|
|
|
TEST(TestThreads, CanRunMulti)
|
|
{
|
|
static std::atomic<int64_t> val;
|
|
class Thread: public Threads
|
|
{
|
|
public:
|
|
Thread(std::atomic<int64_t>&val) : val_(val) {}
|
|
void run(int64_t idx) final
|
|
{
|
|
val += idx;
|
|
while (!ATOMIC_LOAD(&has_set_stop()))
|
|
;
|
|
}
|
|
std::atomic<int64_t> &val_;
|
|
} th(val);
|
|
|
|
val = 0;
|
|
th.set_thread_count(7);
|
|
th.start();
|
|
th.stop();
|
|
th.wait();
|
|
ASSERT_EQ(21, val); // 0+1+2+3+4+5+6
|
|
}
|
|
|
|
TEST(TestThreads, DynamicThread)
|
|
{
|
|
static std::atomic<int64_t> starts;
|
|
static std::atomic<int64_t> exits;
|
|
class: public Threads
|
|
{
|
|
std::atomic<int64_t> n_threads_;
|
|
public:
|
|
int set_thread_count(int64_t n_threads)
|
|
{
|
|
n_threads_ = n_threads;
|
|
return Threads::set_thread_count(n_threads);
|
|
}
|
|
void run(int64_t idx) final
|
|
{
|
|
starts++;
|
|
while (idx < n_threads_ && !has_set_stop())
|
|
;
|
|
exits++;
|
|
}
|
|
} th;
|
|
th.set_thread_count(1);
|
|
th.start();
|
|
while (starts != 1) { ::usleep(10); }
|
|
th.set_thread_count(2);
|
|
while (starts != 2) { ::usleep(10); }
|
|
th.set_thread_count(4);
|
|
while (starts != 4) { ::usleep(10); }
|
|
th.set_thread_count(1);
|
|
while (exits != 3) { ::usleep(10); }
|
|
th.submit([]{});
|
|
//ASSERT_EQ(1, th.get_cur_tasks());
|
|
th.stop();
|
|
th.wait();
|
|
ASSERT_EQ(4, starts);
|
|
ASSERT_EQ(4, exits);
|
|
}
|
|
extern "C" {
|
|
int ob_pthread_create(void **ptr, void *(*start_routine) (void *), void *arg);
|
|
void ob_pthread_join(void *ptr);
|
|
pthread_t ob_pthread_get_pth(void *ptr);
|
|
}
|
|
|
|
void *my_func(void *arg)
|
|
{
|
|
pthread_t *pth = (pthread_t*)arg;
|
|
*pth = pthread_self();
|
|
return NULL;
|
|
}
|
|
TEST(TestThreads, ObPthread)
|
|
{
|
|
pthread_t pth = 0;
|
|
void *tid = NULL;
|
|
ASSERT_EQ(0, ob_pthread_create(&tid, my_func, &pth));
|
|
sleep(1);
|
|
ASSERT_EQ(ob_pthread_get_pth(tid), pth);
|
|
ob_pthread_join(tid);
|
|
}
|
|
int main(int argc, char **argv)
|
|
{
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|