int main() { // Create module module1 = new ContinuousControlManager("ContinuousControl:Manager"); //Dummy test interface //dummyIface = new ContinuousControlInterface("DummyIface"); // Debug DEBUG(LEVEL_INFO, "Created!"); // Connect //dummyIface->q_out_ = &module1->interface->q_in; //module1->interface->q_out_ = &dummyIface->q_in; // Run module boost::thread th1( boost::bind( &ContinuousControlManager::Run, module1) ); boost::thread th2( testThread ) ; // Wait for threads to end th1.join(); th2.join(); return 0; }
int main (int argc, char**argv) { std::cout << "\nwithout lock:\n"; std::thread th1 (print_block,50,'*'); std::thread th2 (print_block,50,'$'); th1.join(); th2.join(); std::cout << "\nwith unique_lock:\n"; std::thread th3 (print_block_lock_guard,50,'*'); std::thread th4 (print_block_lock_guard,50,'$'); th3.join(); th4.join(); std::cout << "\nwith lock_guard:\n"; std::thread th5 (print_block_unique_lock,50,'*'); std::thread th6 (print_block_unique_lock,50,'$'); th5.join(); th6.join(); return 0; }
void testThread() { char arg1[] = "th1"; char arg2[] = "th2"; Thread th1((Thread::Routine)foo, arg1); Thread th2((Thread::Routine)foo, arg2); th1.setBackground(true); th1.start(); th2.start(); #ifdef _WIN32 Thread::sleep(500); th1.suspend(); LOGT("th1 was suspended."); Thread::sleep(500); th2.suspend(); LOGT("th2 was suspended."); Thread::sleep(500); th1.resume(); LOGT("th1 was resumed."); Thread::sleep(500); th2.resume(); LOGT("th2 was resumed."); #endif int ret2 = th2.join(); LOG_VAR(ret2); }
int main(){ boost::thread th1(boost::bind(&push, 0)), th2(pop); th1.join(); th2.join(); return 1; }
int main() { try { boost::barrier tb( 2); boost::fibers::spin::barrier fb( 2); std::cout << "start" << std::endl; boost::thread th1( boost::bind( & f, boost::ref( tb), boost::ref( fb) ) ); boost::thread th2( boost::bind( & g, boost::ref( tb), boost::ref( fb) ) ); th1.join(); th2.join(); std::cout << "finish" << std::endl; return EXIT_SUCCESS; } catch ( boost::system::system_error const& e) { std::cerr << "system_error: " << e.code().value() << std::endl; } catch ( boost::fibers::scheduler_error const& e) { std::cerr << "scheduler_error: " << e.what() << std::endl; } catch ( std::exception const& e) { std::cerr << "exception: " << e.what() << std::endl; } catch (...) { std::cerr << "unhandled exception" << std::endl; } return EXIT_FAILURE; }
void function() { SmartPtr<Derived> myObj = new Derived(); Dummy th1(myObj); // Doesn't work under Cygnus Dummy th2((Base0 *) myObj); // Doesn't work either }
int main() { std::thread th1(print_block, 50, '*'); std::thread th2(print_block, 50, '$'); th1.join(); th2.join(); return 0; }
int main() { queue<int> q; std::thread th1(push,&q); std::thread th2(pop,&q); th1.join(); th2.join(); return 0; }
int main() { std::thread th1([]{ rnd_fkt(1); }); std::thread th2([]{ rnd_fkt(2); }); th1.join(); th2.join(); return 0; }
int main(){ std::thread th1(print_foo); std::thread th2(set_foo, 10); th1.join(); th2.join(); return 0; }
int main () { Hx::thread th1 (task_a); Hx::thread th2 (task_b); th1.join(); th2.join(); return 0; }
int main() { boost::thread th1(&do_thread); th1.join(); //std::string s1; //std::cin >> s1; return boost::report_errors(); }
FileSystem::FileSystem(int port, Membership& m) : membership(m), port(port) { logFile.open("logFileSystem.log"); // we can make all the logs going to a single file, but nah. std::thread th2(&FileSystem::updateThread, this); ringUpdating.swap(th2); std::thread th1(&FileSystem::listeningThread, this); listening.swap(th1); }
int main() { { std::thread th1(print_block, 40, '*'); std::thread th2(print_block, 40, '$'); th1.join(); th2.join(); } std::cout << "=== next run ===========================+\n"; { std::thread th1(print_critial_block, 40, '*'); std::thread th2(print_critial_block, 40, '$'); th1.join(); th2.join(); } return 0; }
int main(){ boost::mutex mutex; Task task1(1, &mutex); Task task2(2, &mutex); boost::thread th1(&Task::run, &task1); boost::thread th2(&Task::run, &task2); th1.join(); th2.join(); return 0; }
void testCondition() { Thread th1((Thread::Routine)changer); Thread th2((Thread::Routine)watcher); th1.start(); th2.start(); th1.join(); th2.join(); }
int main(int argc, char** argv) { int a = 0; spinlock spin; std::thread th1(th_write, std::ref(spin), std::ref(a)); std::thread th2(th_read, std::ref(spin), std::ref(a)); th1.join(); th2.join(); return 0; }
int main(int argc, char** argv) { std::thread th1(print_this); std::thread th2(print_this); std::thread th3(print_this); std::thread th4(print_this); th1.join(); th2.join(); th3.join(); th4.join(); return 0; }
int main() { cv = new std::condition_variable_any; std::thread th2(g); m.lock(); while (!g_ready) cv->wait(m); m.unlock(); std::thread th1(f); th1.join(); th2.join(); }
int main() { std::thread th1(print_block, 20, '*'); std::thread th2(print_block, 20, '#'); std::thread th3(print_block, 20, 'a'); std::thread th4(print_block, 20, '&'); th1.join(); th2.join(); th3.join(); th4.join(); return 0; }
int main() { std::cout << "//////////////////////////// std::async\n"; //////////////////////////// std::async std::vector<int> data(100); // std::iota(std::begin(data), std::end(data)); //called by function std::future<int> result = std::async(accumulate, std::cref(data)); std::cout<<result.get()<<std::endl; //#1 //called by functor Accmulate acc; std::future<int> result2 = std::async(&Accmulate::operator(), &acc, std::cref(data)); std::cout<<result2.get()<<std::endl; //#2 std::cout << "//////////////////////////// std::promise\n"; std::promise<int> pm; std::future<int> result3 = pm.get_future(); std::thread th1 (test, std::ref(result3)); pm.set_value (10); th1.join(); std::cout << "//////////////////////////// std::packaged_task\n"; std::vector<std::packaged_task<int(int, int)>> tasks; std::vector<std::future<int>> futures; for(size_t i = 0; i != 4; ++i){ std::packaged_task<int(int, int)> task(&max); futures.emplace_back(task.get_future()); tasks.push_back(std::move(task)); } //run the tasks asynchronous std::thread t1(std::move(tasks[0]), 3, 4); std::thread t2(std::move(tasks[1]), 4, 5); //run the tasks concurrent tasks[2](5, 4); tasks[3](3, 2); for(auto &data : futures){ std::cout<<data.get()<<std::endl; } t1.join(); t2.join(); }
CosmosQueue::CosmosQueue(unsigned int port, unsigned int sendSize, unsigned int recvSize): cosmos(port), tlmQueue(), cmdQueue() { connected.store(false); tlmCapacity = sendSize; cmdCapacity = recvSize; if (tlmCapacity > 0) { std::thread th1(&CosmosQueue::tlm_thread, this); th1.detach(); } if (cmdCapacity > 0) { std::thread th2(&CosmosQueue::cmd_thread, this); th2.detach(); } }
int main(int, char**) { cv = new std::condition_variable; std::thread th2(g); Lock lk(m); while (!g_ready) cv->wait(lk); lk.unlock(); std::thread th1(f); th1.join(); th2.join(); return 0; }
void testObj::test<3>(void) { double data[2]={1, 2}; Mutex mutex; TestLocker tl1(&mutex, data); TestLocker tl2(&mutex, data); // start two threads Base::Threads::ThreadJoiner th1(tl1); Base::Threads::ThreadJoiner th2(tl2); // and join them th1->join(); th2->join(); }
main() { float a,b,c,d,e,f; printf("\nNhap vao a,b,c,d,e,f : "); scanf("%f %f %f %f %f %f",&a,&b,&c,&d,&e,&f); dd = a*e - d*b; dx = b*f - e*c; dy = a*f - d*c; if (dd != 0) th1(); else if ((dx == dy)&&(dy == 0)) th2(); else th3(); getch(); }
int main(){ boost::thread th1(boost::bind(&insert, 0)), th2(boost::bind(&insert, 1)); th1.join(); th2.join(); for(int i = 0; i < 2; i++){ for(int j = 0; j < 10000; j++){ std::string str; table.search(j+(i*10000), str); std::cout << str << std::endl; } } return 1; }
int main() { cv = new boost::permit_c_any; boost::thread th2(g); Lock lk(m); while (!g_ready) { cv->wait(lk); } lk.unlock(); boost::thread th1(f); th1.join(); th2.join(); return boost::report_errors(); }
int main() { cv = new boost::condition_variable; boost::thread th2(g); Lock lk(m); while (!g_ready) { cv->wait(lk); } lk.unlock(); boost::thread th1(f); th1.join(); th2.join(); return boost::report_errors(); }
int main() { std::thread th1(do_work); std::thread th2(do_work); std::thread th3(do_work); std::thread th4(do_work); std::thread th5(do_work); th1.join(); th2.join(); th3.join(); th4.join(); th5.join(); std::cout << "Result:" << data << '\n'; }
//Multi-thread with on io_service instance and serval handler threads. void test_2() { boost::asio::io_service service; boost::asio::deadline_timer t1(service, boost::posix_time::seconds(5)); t1.async_wait(boost::bind(handler, "timer1", _1)); boost::asio::deadline_timer t2(service, boost::posix_time::seconds(5)); t2.async_wait(boost::bind(handler, "timer2", _1)); boost::asio::deadline_timer t3(service, boost::posix_time::seconds(5)); t3.async_wait(boost::bind(handler, "timer3", _1)); boost::asio::deadline_timer t4(service, boost::posix_time::seconds(5)); t4.async_wait(boost::bind(handler, "timer4", _1)); boost::thread th1([&service]() { service.run(); }); boost::thread th2([&service]() { service.run(); }); th1.join(); th2.join(); }