~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(); }