~TestingSetup()
{
threadGroup.interrupt_all();
threadGroup.join_all();
Bitcredit_UnregisterNodeSignals(Credits_NetParams()->GetNodeSignals());
#ifdef ENABLE_WALLET
delete bitcoin_pwalletMain;
bitcoin_pwalletMain = NULL;
delete bitcredit_pwalletMain;
bitcredit_pwalletMain = NULL;
delete deposit_pwalletMain;
deposit_pwalletMain = NULL;
#endif
delete credits_pcoinsTip;
delete bitcredit_pcoinsdbview;
delete bitcredit_pblocktree;
delete bitcoin_pcoinsTip;
delete bitcoin_pcoinsdbview;
delete bitcoin_pblocktree;
#ifdef ENABLE_WALLET
bitcoin_bitdb.Flush(true);
bitcredit_bitdb.Flush(true);
deposit_bitdb.Flush(true);
#endif
boost::filesystem::remove_all(pathTemp);
}
parallel_test()
{
group_.add_thread( new boost::thread(¶llel_test::insert_sleep_removes_aspect1, this) );
group_.add_thread( new boost::thread(¶llel_test::insert_sleep_removes_aspect2, this) );
group_.add_thread( new boost::thread(¶llel_test::find_and_access, this) );
group_.add_thread( new boost::thread(¶llel_test::insert_sleep_aspect1, this) );
group_.add_thread( new boost::thread(¶llel_test::use_sleep_remove_aspect1, this) );
}
virtual ~Log()
{
_isStopping = true;
_threadPool.interrupt_all();
_threadPool.join_all();
_stringLoggerThread.interrupt();
_stringLoggerThread.join();
}
~TestingSetup()
{
threadGroup.interrupt_all();
threadGroup.join_all();
delete pwalletMain;
pwalletMain = NULL;
delete pcoinsTip;
delete pcoinsdbview;
delete pblocktree;
bitdb.Flush(true);
boost::filesystem::remove_all(pathTemp);
}
void start()
{
if (m_threads.size() > 0)
{ return; }
for(ios_type& ios : m_io_services)
{
m_threads.create_thread(
boost::bind(&ios_type::run,
boost::ref(ios)));
}
}
void client::run_test()
{
unsigned optimal_threads_count = boost::thread::hardware_concurrency();
if (optimal_threads_count == 0)
optimal_threads_count = 1;
ostream_ << "Create " << optimal_threads_count << " threads for client" << std::endl;
for (unsigned i = 0; i < optimal_threads_count; ++i)
threads_.add_thread(new boost::thread([this, i] () { thread_func(i); }));
threads_.join_all();
ostream_ << "All client's threads done" << std::endl;
}
~TestingSetup()
{
threadGroup.interrupt_all();
threadGroup.join_all();
UnregisterNodeSignals(GetNodeSignals());
#ifdef ENABLE_WALLET
delete pwalletMain;
pwalletMain = NULL;
#endif
delete pblocktree;
delete pviewTip;
#ifdef ENABLE_WALLET
bitdb.Flush(true);
#endif
boost::filesystem::remove_all(pathTemp);
}
TestingSetup() {
fPrintToDebugLog = false; // don't want to write to debug.log file
noui_connect();
#ifdef ENABLE_WALLET
bitdb.MakeMock();
#endif
pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
boost::filesystem::create_directories(pathTemp);
mapArgs["-datadir"] = pathTemp.string();
mapArgs["-testnet"] = "true";
pblocktree = new CBlockTreeDB(1 << 20, true);
pviewTip = new TrieView();
LoadBlockIndex();
printf("Loaded\n");
// If the loaded chain has a wrong genesis, bail out immediately
// (we're likely using a testnet datadir, or the other way around).
if (!mapBlockIndex.empty() && chainActive.Genesis() == NULL)
printf("Incorrect or no genesis block found. Wrong datadir for network?");
InitBlockIndex();
printf("Init Done\n");
#ifdef ENABLE_WALLET
bool fFirstRun;
pwalletMain = new CWallet("wallet.dat");
pwalletMain->LoadWallet(fFirstRun);
RegisterWallet(pwalletMain);
#endif
nScriptCheckThreads = 3;
for (int i=0; i < nScriptCheckThreads-1; i++)
threadGroup.create_thread(&ThreadScriptCheck);
RegisterNodeSignals(GetNodeSignals());
}
void start(size_type threadcnt_arg)
{
// one cannot start an empty thread group.
if (0 == threadcnt_arg)
NYAN_FAIL_IFZERO(threadcnt_arg);
else
{
// [mlr] i use a barrier to ensure that that all service loops start
// at the same time. otherwise, there could be race conditions
// during their initialization phase. i need to add 1 because
// my thread is going to wait on this barrier too.
// [mlr][todo] does Service need to support an
// explicit initialization phase? i think perhaps it does.
boost::barrier *ready = new boost::barrier(threadcnt_arg + 1);
// i now start up each service loop on a separate thread.
my_threads.reserve(threadcnt_arg);
for (size_type i = 0; i < threadcnt_arg; ++i)
{
std::ostringstream name;
name << "pool thread " << i;
thread_type * const t =
new thread_type(*ready, name.str());
my_threads.push_back(t);
my_group.create_thread(boost::ref(*t));
}
// now, i wait for all of the threads to signal that
// they're ready to run their main loop.
std::cout << "main pool thread waiting for barrier."
<< std::endl;
ready->wait();
std::cout << "main pool thread continuing."
<< std::endl;
}
}
void AsyncSpinnerImpl::start()
{
boost::mutex::scoped_lock lock(mutex_);
if (continue_)
return;
boost::recursive_mutex::scoped_try_lock spinlock(spinmutex);
if (!spinlock.owns_lock()) {
ROS_WARN("AsyncSpinnerImpl: Attempt to start() an AsyncSpinner failed "
"because another AsyncSpinner is already running. Note that the "
"other AsyncSpinner might not be using the same callback queue "
"as this AsyncSpinner, in which case no callbacks in your "
"callback queue will be serviced.");
return;
}
spinlock.swap(member_spinlock);
continue_ = true;
for (uint32_t i = 0; i < thread_count_; ++i)
{
threads_.create_thread(boost::bind(&AsyncSpinnerImpl::threadFunc, this));
}
}
TestingSetup() {
fPrintToDebugLog = false; // don't want to write to debug.log file
SelectParams(CBaseChainParams::UNITTEST);
noui_connect();
#ifdef ENABLE_WALLET
bitdb.MakeMock();
#endif
pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
boost::filesystem::create_directories(pathTemp);
mapArgs["-datadir"] = pathTemp.string();
pblocktree = new CBlockTreeDB(1 << 20, true);
pcoinsdbview = new CCoinsViewDB(1 << 23, true);
pcoinsTip = new CCoinsViewCache(pcoinsdbview);
InitBlockIndex();
#ifdef ENABLE_WALLET
bool fFirstRun;
pwalletMain = new CWallet("wallet.dat");
pwalletMain->LoadWallet(fFirstRun);
RegisterValidationInterface(pwalletMain);
#endif
nScriptCheckThreads = 3;
for (int i=0; i < nScriptCheckThreads-1; i++)
threadGroup.create_thread(&ThreadScriptCheck);
RegisterNodeSignals(GetNodeSignals());
}
void thread(FFMPEGData &vidData)
{
int counter = 0;
// changed this to use member function.
if (vidData.startFFMPEG() < 0)
{
printf("should not get here.\n");
}
plays.add_thread(new boost::thread(play, vidData));
while (true)
{
printf("\t\tthread count = %d\n", counter);
// Read frames from the stream.
if (av_read_frame(vidData.pFormatCtx, &vidData.pack[counter]) != AVERROR(EAGAIN))
{
if (counter < packetNum)
{
counter++;
}
else
{
counter = 0;
}
}
//Sleep(25);
}
}
/// @brief Constructor.
explicit ThreadPool(std::size_t pool_size)
: running_(true), complete_(true),
available_(pool_size), total_(pool_size) {
for ( std::size_t i = 0; i < pool_size; ++i ) {
threads_.create_thread(
boost::bind(&ThreadPool::main_loop, this));
}
}
void stop(int sig)
{
if (!die) {
die = true;
comm->stop();
monitorThreads.interrupt_all();
}
}
Log(int numOfConsumerThreads = 1) :
_isStopping(false),
_stringLoggerThread(boost::bind(&Log::consumeStringLog, this))
{
for (int i = 0; i < numOfConsumerThreads; ++i)
{
_threadPool.create_thread(boost::bind(&Log::consumeToLog, this));
}
}
bench_atomic(size_t thread_count,
size_t iteration_count)
: x(0)
, iteration_count(0) {
this->iteration_count = iteration_count;
for (size_t i = 0; i < thread_count; ++i) {
threads.create_thread( boost::bind(&bench_atomic::do_test, this) );
}
}
int main(int argc, char** argv) {
init();
if (handle_args(argc, argv) == 1)
return 0;
int processors = boost::thread::hardware_concurrency();
ioService.post(boost::bind(read_images));
ioService.post(boost::bind(assign_workers));
ioService.post(boost::bind(output));
boost::asio::io_service::work work(ioService);
for (int i = 0; i < processors; i++) {
threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &ioService));
}
threadpool.join_all();
return 0;
}
int ctp_trade_init(string tradedir)
{
g_trader=new Trader(g_username,g_password,g_brokerid,g_trade_addr);
g_ctp_trader=new CtpTrader(g_trader,g_dmgr,g_instmgr,tradedir);
g_ctp_trader->init();
g_trade_tg.add_thread(new boost::thread(trader_loop,g_ctp_trader,0));
g_ctp_trader->start();
return 0;
}
int main()
{
{
boost::thread_group threads;
for (int i = 0; i < 3; ++i)
threads.create_thread(&increment_count);
threads.join_all();
}
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
{
boost::thread_group threads;
for (int i = 0; i < 3; ++i)
threads.create_thread(&increment_count);
threads.interrupt_all();
threads.join_all();
}
#endif
{
boost::thread_group threads;
boost::thread* th = new boost::thread(&increment_count);
threads.add_thread(th);
BOOST_TEST(! threads.is_this_thread_in());
threads.join_all();
}
{
boost::thread_group threads;
boost::thread* th = new boost::thread(&increment_count);
threads.add_thread(th);
BOOST_TEST(threads.is_thread_in(th));
threads.remove_thread(th);
BOOST_TEST(! threads.is_thread_in(th));
th->join();
}
{
{
boost::unique_lock<boost::mutex> lock(mutex);
boost::thread* th2 = new boost::thread(&increment_count_2);
threads2.add_thread(th2);
}
threads2.join_all();
}
return boost::report_errors();
}
int main()
{
std::ifstream input(BINARY_DIR"/input.txt", std::ios::binary);
SyncClass sc;
for(int i = 0;i < THREADS_COUNT; i++)
threads.create_thread(boost::bind(&SyncClass::writeMessage, &sc) );
while(!input.eof()){
Message msg(input);
if(input.eof())
break;
boost::mutex::scoped_lock lock(queueMutex);
msgQueue.push(msg);
}
sc.stopWorking();
threads.join_all();
return 0;
}
// Sets that the program should finish.
void deinit()
{
programRunning = FALSE;
#if _USE_MT
threads.join_all();
#endif
_aligned_free(spherePositions);
_aligned_free(sphereData);
}
NMBLSEXPORT void handleLoadLibrary(boost::asio::io_service &, std::string root, bool debug)
{
docroot = root;
worker_thread.create_thread(sqliteworker);
std::cout << "Hi form handle load lib" << std::endl;
is_running_as_debug = debug;
sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
}
thread_pool(std::size_t pool_size) :
work_(io_service_), signals_(io_service_, SIGINT, SIGTERM)
{
DLOG(INFO)<< __func__;
for (std::size_t idx = 0; idx < pool_size; ++idx)
{
threads_.create_thread( boost::bind(&boost::asio::io_service::run, boost::ref(io_service_)));
}
signals_.async_wait( boost::bind(&boost::asio::io_service::stop, &io_service_));
}
void waitTermination( boost::thread_group& threads, std::initializer_list< int > signals = { SIGINT, SIGTERM, SIGQUIT } )
{
sigset_t sset;
sigemptyset( &sset );
for( const auto each: signals )
{
sigaddset( &sset, each );
}
sigprocmask( SIG_BLOCK, &sset, nullptr );
std::cout << "threads running: " << threads.size() << "; main thread waiting for termination signals...\n";
int sig = 0;
sigwait( &sset, &sig );
std::cout << "termination signal " << sig << " has been caught\n" << "interrupting threads...\n";
threads.interrupt_all();
}
/**
* Note: Caller must hold m_Mutex
*/
void ThreadPool::Queue::SpawnWorker(boost::thread_group& group)
{
for (size_t i = 0; i < sizeof(Threads) / sizeof(Threads[0]); i++) {
if (Threads[i].State == ThreadDead) {
Log(LogDebug, "base", "Spawning worker thread.");
Threads[i] = WorkerThread(ThreadIdle);
Threads[i].Thread = group.create_thread(boost::bind(&ThreadPool::WorkerThread::ThreadProc, boost::ref(Threads[i]), boost::ref(*this)));
break;
}
}
}
void cia_client::stop()
{
if (!m_started_) return;
m_started_ = false;
m_sock_.close();
m_deal_ch_msg_group.interrupt_all();
ptr self = shared_from_this();
auto it = std::find(clients.begin(), clients.end(), self);
clients.erase(it);
BOOST_LOG_SEV(cia_g_logger, Debug) << "客户端socket已经调用stop函数关闭";
//x m_config_server->set_started(true); // 为了防止网络情况异常, 造成服务端关闭连接后重置此值为2, 通讯端保证此值为1
}
std::tuple<bool, boost::thread*> RunDacrs(int argc, char* argv[]) {
boost::thread* detectShutdownThread = NULL;
static boost::thread_group threadGroup;
SetupEnvironment();
bool fRet = false;
// Connect Dacrsd signal handlers
noui_connect();
fRet = AppInit(argc, argv, threadGroup);
detectShutdownThread = new boost::thread(boost::bind(&DetectShutdownThread, &threadGroup));
if (!fRet) {
if (detectShutdownThread)
detectShutdownThread->interrupt();
threadGroup.interrupt_all();
}
return std::make_tuple(fRet, detectShutdownThread);
}
/// @brief Destructor.
~ThreadPool() {
// Set running flag to false then notify all threads.
{
boost::unique_lock< boost::mutex > lock(mutex_);
running_ = false;
condition_.notify_all();
}
try {
threads_.join_all();
}
// Suppress all exceptions.
catch (const std::exception&) {}
}
int ctp_quote_init(string quotedir)
{
int ret=0;
int i,count;
char **ppinstn;
g_quoter=new Quoter(g_username,g_password,g_brokerid,g_quote_addr);
g_ctp_quoter=new CtpQuoter(g_quoter,g_dmgr,g_instmgr,quotedir);
g_mdservice=new mdservice();
g_ctp_quoter->init(g_mdservice);
/*
*todo regmd all
* */
/*-1=get old, 1=get new, 0=get all*/
g_ctp_quoter->pinstmgr->get_inst_list(&ppinstn,&count, 0);
LOG_DEBUG<<"get_inst_list count:"<<count<<std::endl;
for(i=0;i<count;i++) {
//regmd
//1.to fix this code, rebuild. 2. if new inst, we need regmd...
g_ctp_quoter->mds->regmd(ppinstn[i], g_ctp_quoter->pinstmgr->instmap[ppinstn[i]]);
//reg one minute k
ret=g_ctp_quoter->mds->regmd_period(ppinstn[i],MINUTE,1);
assert(ret==0);
g_ctp_quoter->mds->loadmd_period(ppinstn[i], 1, g_dmgr);
}
LOG_DEBUG<<"ctp_quote_init get all inst and reg all the md"<<std::endl;
for (i=0;i< CTP_WORK_THREAD_NUM;i++){
g_quote_tg.add_thread(new boost::thread(DepthMarketProcess,g_ctp_quoter,i));
}
g_quote_tg.add_thread(new boost::thread(quote_loop,g_ctp_quoter));
g_ctp_quoter->start();
g_io_tg.add_thread(new boost::thread(quote_io_work));
return 0;
}
void AsyncSpinnerImpl::stop()
{
boost::mutex::scoped_lock lock(mutex_);
if (!continue_)
return;
ROS_ASSERT_MSG(member_spinlock.owns_lock(),
"Async spinner's member lock doesn't own the global spinlock, hrm.");
ROS_ASSERT_MSG(member_spinlock.mutex() == &spinmutex,
"Async spinner's member lock owns a lock on the wrong mutex?!?!?");
member_spinlock.unlock();
continue_ = false;
threads_.join_all();
}