void fiber::join() { // FIXME: must fiber::join() be synchronized? if ( context::active()->get_id() == get_id() ) { throw fiber_error( std::make_error_code( std::errc::resource_deadlock_would_occur), "boost fiber: trying to join itself"); } if ( ! joinable() ) { throw fiber_error( std::make_error_code( std::errc::invalid_argument), "boost fiber: fiber not joinable"); } impl_->join(); impl_.reset(); }
void Thread::join() { if (!mIsCreated) return; if (!joinable()) return; #if ENALBE_LOG cout << "Thread::join name = " << mName << ", id = " << mThread.get_id() << endl; #endif mThread.join(); mIsCreated = false; }
bool gcore::Thread::join(int *retval) { if (joinable()) { if (WaitForSingleObject((HANDLE)mSelf,INFINITE) == WAIT_OBJECT_0) { if (retval != 0) { DWORD dw; GetExitCodeThread((HANDLE)mSelf, &dw); *retval = dw; } CloseHandle((HANDLE)mSelf); mSelf = 0; mSelfId = 0; return true; } } return false; }
void tbb_thread_v3::detach() { __TBB_ASSERT( joinable(), "only joinable thread can be detached" ); #if _WIN32||_WIN64 BOOL status = CloseHandle( my_handle ); if ( status == 0 ) handle_win_error( GetLastError() ); my_thread_id = 0; #elif USE_LITHE __TBB_ASSERT(0, "detach not implemented for lithe contexts" ); #else int status = pthread_detach( my_handle ); if( status ) handle_perror( status, "pthread_detach" ); #endif // _WIN32||_WIN64 my_handle = 0; }
Relation Relation::join(Relation &r){ Relation s("test", joinSchemes(schema, r.schema)); int before = schema.attributes.size() + r.schema.attributes.size(); int after = s.schema.attributes.size(); bool fast = (before == after); set<Tuple>::iterator it1; for(it1 = tuples.begin(); it1 != tuples.end(); it1++){ set<Tuple>::iterator it2; for(it2 = r.tuples.begin(); it2 != r.tuples.end(); it2++){ if(fast) s.fastJoin((*it1), (*it2)); else if(joinable(schema, r.schema, (*it1), (*it2))) s.joinTuples(schema, r.schema, (*it1), (*it2)); } } return s; }
void thread::join() { if (this->get_id() == this_thread::get_id()) { throw system_error(make_error_code(errc::resource_deadlock_would_occur), "Joining this leads to a deadlock."); } if (joinable()) { auto status = thread_getstatus(m_handle); if (status != STATUS_NOT_FOUND && status != STATUS_STOPPED) { m_data->joining_thread = sched_active_pid; thread_sleep(); } m_handle = thread_uninitialized; } else { throw system_error(make_error_code(errc::invalid_argument), "Can not join an unjoinable thread."); } // missing: no_such_process system error }
void tbb_thread_v3::join() { __TBB_ASSERT( joinable(), "thread should be joinable when join called" ); #if _WIN32||_WIN64 DWORD status = WaitForSingleObject( my_handle, INFINITE ); if ( status == WAIT_FAILED ) handle_win_error( GetLastError() ); BOOL close_stat = CloseHandle( my_handle ); if ( close_stat == 0 ) handle_win_error( GetLastError() ); my_thread_id = 0; #else int status = pthread_join( my_handle, NULL ); if( status ) handle_perror( status, "pthread_join" ); #endif // _WIN32||_WIN64 my_handle = 0; }
bool Thread::start() { if (mIsCreated) return true; mRunning = true; mThread = std::thread( std::bind(&Thread::threadFunc,this) ); #if ENALBE_LOG cout << "创建线程 name = " << mName << ", id = " << mThread.get_id() << endl; #endif if (!joinable()) mThread.detach(); mIsCreated = true; return mRunning; }
void test_container_mt_stop_empty() { test_mt_handler th; proton::container c(th); c.auto_stop( false ); container_runner runner(c); auto t = std::thread(runner); // Must ensure that thread is joined or detached try { ASSERT_EQUAL("start", th.wait()); c.stop(); t.join(); ASSERT_EQUAL("", th.error().name()); } catch (...) { // We don't join as we don't know if we'll be stuck waiting if (t.joinable()) { t.detach(); } throw; } }
void test_container_mt_stop() { test_mt_handler th; proton::container c(th); c.auto_stop(false); container_runner runner(c); auto t = std::thread(runner); // Must ensure that thread is joined or detached try { test_listen_handler lh; c.listen("//:0", lh); // Also opens a connection ASSERT_EQUAL("start", th.wait()); ASSERT_EQUAL("open", th.wait()); c.stop(); t.join(); } catch (...) { // We don't join as we don't know if we'll be stuck waiting if (t.joinable()) { t.detach(); } throw; } }
void tbb_thread_v3::join() { __TBB_ASSERT( joinable(), "thread should be joinable when join called" ); #if _WIN32||_WIN64 #if __TBB_WIN8UI_SUPPORT std::thread* thread_tmp=(std::thread*)my_thread_id; thread_tmp->join(); delete thread_tmp; #else // __TBB_WIN8UI_SUPPORT DWORD status = WaitForSingleObjectEx( my_handle, INFINITE, FALSE ); if ( status == WAIT_FAILED ) handle_win_error( GetLastError() ); BOOL close_stat = CloseHandle( my_handle ); if ( close_stat == 0 ) handle_win_error( GetLastError() ); my_thread_id = 0; #endif // __TBB_WIN8UI_SUPPORT #else int status = pthread_join( my_handle, NULL ); if( status ) handle_perror( status, "pthread_join" ); #endif // _WIN32||_WIN64 my_handle = 0; }
js::Thread::~Thread() { LockGuard<Mutex> lock(idMutex_); MOZ_RELEASE_ASSERT(!joinable(lock)); }
bool js::Thread::joinable() { LockGuard<Mutex> lock(idMutex_); return joinable(lock); }
~thread () { if (joinable()) std::terminate(); }
void GLFWRenderer::run() { glfwSetDropCallback(window, drop_cb); glfwSetKeyCallback(window, key_cb); glfwSetMouseButtonCallback(window, mouse_cb); auto render_thread = std::thread([this] { glfwMakeContextCurrent(window); std::string text = "Lorem ipsum dolor sit amet,\n" "consectetur adipisicing elit,\n" "sed do eiusmod tempor incididunt\n" "ut labore et dolore magna aliqua."; int size = 48; LazyText t1("NotoSans-Regular", size); t1.setText(text); // t1.setAlign(LazyText::TextAlign::Center); // t1.setColor(1, 0.5, 0); // t1.setOpacity(90); // t1.setSpacing(2); LazyText t2("NotoSerif-Regular", size); t2.setText(text); // t2.setColor(0.5, 1, 1); // t2.setOpacity(60); // t2.setSpacing(2); LazyText t3("NotoMono-Regular", size); t3.setText(text); // t3.setColor(1, 0.5, 0.5); // t3.setOpacity(80); // t3.setSpacing(2); while (!glfwWindowShouldClose(window)) { glfwMakeContextCurrent(window); // glClearColor(1.0f, 1.0f, 1.0f, 1.0f); // glClearColor(0.5f, 0.5f, 0.5f, 1.0f); // glClearColor(0.25f, 0.25f, 0.25f, 1.0f); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); // glFrustum(fNear *(-fFov * ratio + headX), // fNear *(fFov * ratio + headX), // fNear *(-fFov + headY), // fNear *(fFov + headY), // fNear, fFar); glOrtho(0, width, height, 0, 0, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); drawGrid(4, 4); // t1.setOpacity((sin(glfwGetTime() * 4) + 4) * 20.0f); // t2.setOpacity((sin(glfwGetTime() * 4 + 1.0) + 4) * 20.0f); // t3.setOpacity((sin(glfwGetTime() * 4 + 2.0) + 4) * 20.0f); // static int frame_no = 1; // t1.setText(to_string(frame_no)); // t2.setText(to_string(frame_no)); // t3.setText(to_string(frame_no)); // frame_no++; // t1.setAlign(LazyText::TextAlign::Left); t1.setAlign(LazyText::TextAlign::Center); // t1.setAlign(LazyText::TextAlign::Right); t1.setOrigin(0.5, 0.5); t1.drawAll(width / 2, height / 2); // t2.drawText(width / 2, 70 + size * 2); // t3.drawText(width / 2, 90 + size * 3); // t1.setSize(size); // t2.setSize(size); // t3.setSize(size); // size++; glfwSwapBuffers(window); sleepUntilNextFrame(15); } }); while (!glfwWindowShouldClose(window)) { glfwWaitEvents(); } if (render_thread.joinable()) render_thread.join(); }
int _tmain(int argc, _TCHAR* argv[]) { _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); srand(NetGetTime()); Peer* sender; int size; NetConnection connection; connection.Open(5008); NetConnection server; server.Open(5007); connection.connection.SetRTT(0); connection.connection.SetDrop(0); connection.connection.SetVariance(0); printf("Doing Connection Security Test\n"); for (int i = 0; i < 50; i++) { char* buffer = new char[i*6]; for (int in = 0; in < i*6; in++) { buffer[in] = rand(); } connection.connection.Send(Address(127,0,0,1,5007), buffer, i*6); delete[] buffer; } NetSleep(1000);//wait to receive messages //get all messages out char* out; while (out = server.Receive(sender, size)) { delete[] out; } if (server.peers.size() != 0) printf("Connection security test failed!!!\n\n"); else printf("Connection security test passed.\n\n"); auto t = std::thread([](NetConnection* server) { while (true) { Peer* sender; int size; server->Receive(sender, size); if (server->peers.size() > 5) return; } }, &server); int status = connection.Connect(Address(127,0,0,1,5007), "testing", 0); if (status < 0) { printf("Connection Test Failed!!!\n"); } NetConnection cons[5]; for (int i = 0; i < 5; i ++) { cons[i].Open(5010+i); int stat = cons[i].Connect(Address(127,0,0,1,5007), "yo", 0); if (stat < 0) printf("Connection test failed!\n"); } if (t.joinable()) t.join(); printf("Connection Test Successful\n"); for (int i = 0; i < 5; i++) { //cons[i].Disconnect(); cons[i].Close(); } while (server.peers.size() > 1) { Peer* s; int size; server.Receive(s, size); NetSleep(1); } printf("Connections closed successfully\n\n"); printf("Doing Security Test\n"); for (int i = 0; i < 50; i++) { char* buffer = new char[i*6]; for (int in = 0; in < i*6; in++) { buffer[in] = rand(); } connection.connection.Send(connection.peers.begin()->second->connection.remoteaddr, buffer, i*6); delete[] buffer; } NetSleep(1000);//wait to receive messages //get all messages out //char* out; while (out = server.Receive(sender, size)) { delete[] out; } printf("Well, we didnt crash, so security test probably didn't fail...\n\n"); connection.connection.SetRTT(0.05); connection.connection.SetDrop(0.1); connection.connection.SetVariance(0.02); //start testing printf("Testing reliable messages...\n"); int num = 50; while(num-- > 0) { int data[200]; for (int i = 0; i < 200; i++) { data[i] = rand(); } connection.SendReliable((char*)data, sizeof(data)); //ok, now check Peer* sender; int size; while (true) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data)) { for (int i = 0; i < 200; i++) { assert(((int*)buffer)[i] == data[i]); } //printf("one good\n"); } else { printf("Bad message size!!!\n"); } delete[] buffer; break; } } } printf("Reliable message sending passed!\n\n"); printf("Testing reliable ordered messages...\n"); num = 50; int data[20][200]; for (int i = 0; i < 20; i++) { for (int i2 = 0; i2 < 200; i2++) { data[i][i2] = rand(); } data[i][0] = i; connection.peers.begin()->second->connection.SendReliableOrdered((char*)data[i], sizeof(data[i]), 5); } //ok, now check num = 0; while (num < 20) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data[0])) { for (int i = 0; i < 200; i++) { assert(((int*)buffer)[i] == data[num][i]); } //printf("one good\n"); } else { printf("Bad message size!!!\n"); } num++; delete[] buffer; } } printf("Ordered Reliable Message Sending Passed!\n\n"); printf("Testing Split Reliable Ordered Messages...\n"); num = 50; int data2[20][500]; for (int i = 0; i < 20; i++) { for (int i2 = 0; i2 < 500; i2++) { data2[i][i2] = rand(); } data2[i][0] = i; connection.peers.begin()->second->connection.SendReliableOrdered((char*)data2[i], sizeof(data2[i]), 5); } //ok, now check //Peer* sender; int size; num = 0; while (num < 20) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data2[0])) { for (int i = 0; i < 500; i++) { assert(((int*)buffer)[i] == data2[num][i]); } } else { printf("Bad message size!!!\n"); } num++; delete[] buffer; } } printf("Ordered Split Reliable Message Sending Passed!\n\n"); printf("Testing Reliable Message Splitting...\n"); //test splitting num = 50; while(num-- > 0) { int data[800]; for (int i = 0; i < 800; i++) { data[i] = rand(); } connection.SendReliable((char*)data, sizeof(data)); //ok, now check Peer* sender; int size; while (true) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data)) { for (int i = 0; i < 800; i++) { assert(((int*)buffer)[i] == data[i]); } } else { printf("Bad message size!!!\n"); } delete[] buffer; break; } } } printf("Reliable Message Splitting Sending Passed!\n\n"); connection.connection.SetRTT(0); connection.connection.SetDrop(0); connection.connection.SetVariance(0); //test unreliable printf("Testing unreliable message sending...\n"); //test splitting num = 50; while(num-- > 0) { int data[200]; for (int i = 0; i < 200; i++) { data[i] = rand(); } connection.Send((char*)data, sizeof(data)); //ok, now check Peer* sender; int size; while (true) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data)) { for (int i = 0; i < 200; i++) { assert(((int*)buffer)[i] == data[i]); } } else { printf("Bad message size!!!\n"); } delete[] buffer; break; } } } printf("Unreliable message sending passed!\n\n"); //test unreliable splitting printf("Testing unreliable message splitting...\n"); num = 50; while(num-- > 0) { int data[800]; for (int i = 0; i < 800; i++) { data[i] = rand(); } connection.Send((char*)data, sizeof(data)); //ok, now check Peer* sender; int size; while (true) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data)) { for (int i = 0; i < 800; i++) { assert(((int*)buffer)[i] == data[i]); } } else { printf("Bad message size!!!\n"); } delete[] buffer; break; } } } printf("Unreliable message splitting sending passed!\n\n"); //test packet coalesing printf("Testing unreliable message coalescing...\n"); num = 50; while(num-- > 0) { int data[121]; for (int i = 0; i < 121; i++) { data[i] = rand(); } connection.Send((char*)data, sizeof(data)); connection.Send((char*)data, sizeof(data)); connection.Send((char*)data, sizeof(data)); connection.SendPackets();//force send //ok, now check Peer* sender; int size; for (int i = 0; i < 3; i++) { while (true) { char* buffer = server.Receive(sender, size); if (buffer) { if (size == sizeof(data)) { for (int i = 0; i < 121; i++) { assert(((int*)buffer)[i] == data[i]); } } else { printf("Bad message size!!!\n"); } delete[] buffer; break; } } } } printf("Unreliable message coalescing passed!\n\n"); printf("Testing Disconnection...\n"); connection.Disconnect(); while (true) { Peer* sender; int size; server.Receive(sender, size); if (server.peers.size() == 0) break; } printf("Disconnection successful!\n"); //while (true) NetSleep(10000); return 0; }
CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<std::string()> thread_name) : m_state( { CPU_STATE_STOPPED }) , m_id(Emu.GetIdManager().get_current_id()) , m_type(type) , m_name(name) { start(std::move(thread_name), [this] { SendDbgCommand(DID_CREATE_THREAD, this); std::unique_lock<std::mutex> lock(mutex); // check thread status while (joinable() && is_alive()) { CHECK_EMU_STATUS; // check stop status if (!is_stopped()) { if (lock) lock.unlock(); try { task(); } catch (CPUThreadReturn) { ; } catch (CPUThreadStop) { m_state |= CPU_STATE_STOPPED; } catch (CPUThreadExit) { m_state |= CPU_STATE_DEAD; break; } catch (const fmt::exception&) { dump_info(); throw; } m_state &= ~CPU_STATE_RETURN; continue; } if (!lock) { lock.lock(); continue; } cv.wait(lock); } }); }
Thread::~Thread() { decaf_check(!joinable()); }
~fiber() { if ( joinable() ) { std::terminate(); } }
base::thread::~thread() { if (joinable()) detach(); }
thread::~thread() { if (joinable()) { terminate(); } }