Пример #1
0
void customer()
{
    std::unique_lock<std::mutex> graud(mut);

    if(mut.try_lock())
    {
        std::cout << "mutex unlocked after unique_lock" <<std::endl;
    }else{
        std::cout <<"mutex locked after unique_lock" <<std::endl;
    }

    while(flag == 0)
    {
        std::cout << "wait........." <<std::endl;
        cond.wait(graud);
    }


    if(mut.try_lock())
    {
        std::cout << "mutex unlocked after wait" <<std::endl;
    }else{
        std::cout <<"mutex locked after wait" <<std::endl;
    }

    std::cout << "flag = " << flag << std::endl;
}
Пример #2
0
void f()
{
    time_point t0 = Clock::now();
    assert(!m.try_lock());
    assert(!m.try_lock());
    assert(!m.try_lock());
    while(!m.try_lock())
        ;
    time_point t1 = Clock::now();
    m.unlock();
    ns d = t1 - t0 - ms(250);
    assert(d < ns(50000000));  // within 50ms
}
Пример #3
0
    /**
     *  To remove from the list, we need to keep a pointer to the previous
     *  node, too.  Note that this is much easier on account of us having a
     *  sentinel
     */
    void remove(int val)
    {
		while (true) {
			if (linkMtx.try_lock()) { 
				// find the node whose val matches the request
				Node* prev = sentinel;
				Node* curr = prev->next;
				while (curr != NULL) {
					// if we find the node, disconnect it and end the search
					if (curr->val == val) {
						prev->next = curr->next;

						// delete curr...
						free(curr);
						break;
					}
					else if (curr->val > val) {
						// this means the search failed
						break;
					}
					// advance one node
					prev = curr;
					curr = prev->next;
				}
				linkMtx.unlock();
				return;
			}
		}
    }
					void deliver_new_event(std::size_t, const void* inbnd) {
#ifndef NDEBUG
						bool success = assert_single_threaded.try_lock();
						assert(success);
						AtScopeEnd ase{[&]{assert_single_threaded.unlock();}};
#endif
						//std::cout << "received message" << std::endl;
						if (on_first_message){
							//std::cout << "expected this message is size_t" << std::endl;
							recv.first = *((int*)(inbnd));
							on_first_message = false;
							event_fd.notify();
							//async_tick(c);
						}
						else{
							//std::cout << "expected this message is vector" << std::endl;
							recv.second = from_bytes<std::vector<unsigned char> >(nullptr,((char*) inbnd));
							{
								stringstream ss;
								ss << "received " << recv.second->size() << " element vector" << std::endl;
								//std::cout << ss.str();
							}
							on_first_message = true;
							event_fd.notify();
							//async_tick(c);
						}
					}
Пример #5
0
    /**
     * insert method; find the right place in the list, add val so that it is
     * in sorted order; if val is already in the list, exit without inserting
     */
    void insert(int val)
    {
		while (true) {
			if (linkMtx.try_lock()) { 
				// traverse the list to find the insertion point
				Node* prev =sentinel;
				Node* curr = prev->next;
				while (curr != NULL) {
					if (curr->val >= val)
						break;
					prev = curr;
					curr = prev->next;
				}

				// now insert new_node between prev and curr
				//
				// NB: if the test fails, it means we quit the above loop on account
				// of /finding/ val, in which case we just exit
				if (!curr || ((curr->val) > val)) {
					// create the new node
					Node* i = (Node*)malloc(sizeof(Node));
					i->val = val;
					i->next = curr;
					// insert it
					prev->next = i;
				}
				linkMtx.unlock();
				return;
			}
		}
    }
Пример #6
0
void attempt_10k_incresses() {
	for (auto i = 0; i < 10000; ++i)
		if (mtx.try_lock()) {	// only increase if currently not locked
			++counter;
			mtx.unlock();
		}
}
Пример #7
0
void SimulateClient(InternetCafe* internetCafe, std::vector<Client*>& clients, unsigned int clientId, std::mutex& mtx)
{
	Client* curClient = nullptr;
	curClient = clients[clientId];
	bool clientIsRunning = true;

	if (curClient)
	{
		while (clientIsRunning)
		{
			if (mtx.try_lock())
			{
				if (internetCafe->RequestComputer(curClient->GetId(), curClient->GetMoney(), clientIsRunning))
				{
					curClient->SetMoney(curClient->GetMoney() - internetCafe->GetHireCost());
				}

				mtx.unlock();
			}

			std::this_thread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>
				(std::chrono::duration<double, std::ratio<1, 1000>>(TIMESTEP)));
		}

		std::cout << "User " << curClient->GetId() << " has exited simulation" << std::endl;
	}
}
        // the main device method
        virtual void run() {

            if(!opened) {

                scene->addItem(item);

                // lock the image viewer
                img_view_mutex.lock();

                // update the pixmap and unlock the image viewer
                show_image();

                // open a window to show the QGraphicsScene
                view->show();

                // set the flag to true
                opened = true;

            } else {

                if (img_view_mutex.try_lock())  {

                    // a new thread!
                    std::thread show_image_thread(&ImageViewerDevice::show_image, this);

                    // leave it alone
                    show_image_thread.detach();

                }

            }

        }
Пример #9
0
/**
 * I hope everyone come inside, and everyone know
 * how many had been here
 */
int wait_for_all_entering_ep()
{  
    static std::atomic<bool> wait_finish;
    static std::atomic<int> thread_inside_count;
    static std::atomic<int> saved_thread_inside_count;

    static std::mutex mtx;

    wait_finish = false;
    thread_inside_count++;
    if (mtx.try_lock())
    {  
        while (thread_inside_count != get_expected_thread_count())
        {  
            // Well, furiosly infinit looping until all the threads runnin in the 
            // kernel are trapped here
        }
        saved_thread_inside_count = thread_inside_count.load();
        wait_finish = true;
        mtx.unlock();
    }
    else
    {
        while (wait_finish == false);
    }

    thread_inside_count--;
    return saved_thread_inside_count.load();
}
 bool try_lock()
 {
     check_for_hierarchy_violation();
     if(!internal_mutex.try_lock())
         return false;
     update_hierarchy_value();
     return true;
 }
Пример #11
0
void attempt_10k_inc() {
    for (int i=0; i<10000; ++i) {
        if (mtx.try_lock()) {
            // only increase if lock can be got successfully
            ++counter;
            mtx.unlock();
        }
    }
}
Пример #12
0
void ConnectOnInput(int wiimote_number)
{
  if (!g_wiimotes_mutex.try_lock())
    return;

  if (g_wiimotes[wiimote_number])
    g_wiimotes[wiimote_number]->ConnectOnInput();

  g_wiimotes_mutex.unlock();
}
Пример #13
0
  bool try_lock() {
    if (_mutex.try_lock())
      {
	_isLocked = true;
	return true;
      }
    else {
      _isLocked = false;
      return false;
    }
  };
Пример #14
0
void iDroneFSM() {

    while (run) {
        if (navLock.try_lock()) {
            fsm.act(model);
            navLock.unlock();
        }


        //std::this_thread::sleep_for(std::chrono::seconds(2));

    }
}
void threadfunction_mutex_try_lock(int arg) 
{
  long long count = 0;
  while(true) {
    if(coutLock.try_lock()) {
        cout << "mutex try_lock: " << arg << ", this_thread::get_id=" << this_thread::get_id() << ", tried " << count << " times before we attained the lock" << "\n";
      coutLock.unlock();
      break;
    } else { // lock is busy, do something else.  Let's count the number of times we tried.
      count++;
    }
  }
}
Пример #16
0
void thread_function_increase()
{
    for (int i=0; i<3; i++)
    {
        if(g_counter_mutex.try_lock())
            //g_counter_mutex.lock();
        {
            ++g_counter;
            cout << this_thread::get_id() << ": " << i << endl;
            g_counter_mutex.unlock();
            this_thread::sleep_for(std::chrono::seconds(2));
        }
    }
}
Пример #17
0
void CBaLog::logRoutine(TBaCoreThreadArg *pArg) {
   while (!sLogdArg.exitTh) {

      // Crate and delete have preference to avoid deadlocks.
      // deleting a logger flushed it anyways
      if (sMtx.try_lock()) {
         // iterate loggers
         for (auto &kv : sLoggers) {
            kv.second->Flush();
         }
         sMtx.unlock();
      }
      BaCoreMSleep(50);
   }
}
Пример #18
0
void func(size_t thread_index, tree_mutex *m)
{
	size_t n = 10000;
	//dbg(thread_index, n);
	while (n--)
	{
		m->lock(thread_index);
		assert(m2.try_lock());
		++i;
		++ai;
		++ai2;
		m2.unlock();
		m->unlock(thread_index);
	}
}
Пример #19
0
void manage_func()
{
    while (!g_finish)
    {
        if (g_mtx.try_lock())
        {
            if (expected_thread_count != MAX_THREAD_COUNT)
            {
                expected_thread_count--;
            }
            g_mtx.unlock();
        }
        
        std::this_thread::yield();
    }
}
Пример #20
0
void notify_each_run()
{
    // sometimes, we just random to set the thread count to the expected value
    // to increase the possibility to somewhat racing condition
    if (g_mtx.try_lock())
    {
        if (random() % 88 > 44)
        {
            expected_thread_count = MAX_THREAD_COUNT * 2;
        }
        else
        {
            expected_thread_count = MAX_THREAD_COUNT;
        }
        g_mtx.unlock();
    }
}
Пример #21
0
// Read the Wiimote once
void Update(int wiimote_number)
{
  // Try to get a lock and return without doing anything if we fail
  // This avoids blocking the CPU thread
  if (!g_wiimotes_mutex.try_lock())
    return;

  if (g_wiimotes[wiimote_number])
    g_wiimotes[wiimote_number]->Update();

  // Wiimote::Update() may remove the Wiimote if it was disconnected.
  if (!g_wiimotes[wiimote_number])
  {
    Host_ConnectWiimote(wiimote_number, false);
  }

  g_wiimotes_mutex.unlock();
}
Пример #22
0
    /**
     * lookup method: just traverse the list in order, and see if we find the
     * val
     */
    bool lookup(int val)
    {
		while (true) {
			if (linkMtx.try_lock()) { 
				Node* curr = sentinel->next;

				while (curr != NULL) {
					if (curr->val >= val)
						break;
					curr = curr->next;
				}

				bool result = ((curr != NULL) && (curr->val == val));
				linkMtx.unlock();
				return result;
			}
		}
    }
        bool try_put(messageT msg) { // Try to put a single message into the mailbox

            if( queue_mutex.try_lock() ) {

                // Push message into mailbox
                messages.push(msg);

                // Signal there is a message in the mailbox
                msg_available_cv.notify_one();

                // Unlock queue
                queue_mutex.unlock();

                return true;
            }
            // Otherwise, say mailbox is unavailable
            else
                return false;
        }
Пример #24
0
bool ProxygenServer::sniNoMatchHandler(const char *server_name) {
  try {
    if (!RuntimeOption::SSLCertificateDir.empty()) {
      static std::mutex dynLoadMutex;
      if (!dynLoadMutex.try_lock()) return false;
      SCOPE_EXIT { dynLoadMutex.unlock(); };

      // Reload all certs.
      Logger::Warning("Reloading SSL certificates upon server name %s",
                       server_name);
      ServerNameIndication::load(RuntimeOption::SSLCertificateDir,
                                 std::bind(&ProxygenServer::dynamicCertHandler,
                                           this,
                                           std::placeholders::_1,
                                           std::placeholders::_2,
                                           std::placeholders::_3));
      return true;
    }
  } catch (const std::exception &ex) {
    Logger::Error("Failed to reload certificate files or key files");
  }
  return false;
}
Пример #25
0
void ImageLoader::UpdateTextures()
{
    if (PendingUploads.size() && LoadMutex.try_lock())
    {
        for (auto i = PendingUploads.begin(); i != PendingUploads.end(); i++)
        {
            ImageData imgData;
            imgData.Data = i->second.Data;
            imgData.Width = i->second.Width;
            imgData.Height = i->second.Height;

            Image::LastBound = InsertImage(i->first, &imgData);

            free(imgData.Data);
        }

        PendingUploads.clear();
        LoadMutex.unlock();
    }

    if (Textures.size())
    {
        for (auto i = Textures.begin(); i != Textures.end();)
        {
            if (i->second->IsValid) /* all of them are valid */
                break;

            if (Load(i->first) == nullptr) // If we failed loading it no need to try every. single. time.
            {
                i = Textures.erase(i);
                continue;
            }

            ++i;
        }
    }
}
Пример #26
0
int __cdecl HandleCrash(PEXCEPTION_POINTERS pExceptPtrs)
{
	/* only allow one thread to crash. */
	if(!m_crashLock.try_lock())
	{
		TerminateThread(GetCurrentThread(), static_cast<DWORD>(-1));
		return EXCEPTION_EXECUTE_HANDLER;
	}

	// Create the date/time string
	tm pTime;
	time_t curtime = time(NULL);
	localtime_s(&pTime, &curtime);

	char	filename[MAX_PATH];
	TCHAR	modname[MAX_PATH*2];

	ZeroMemory(filename, sizeof(filename));
	ZeroMemory(modname, sizeof(modname));

	if(GetModuleFileName(0, modname, MAX_PATH*2-2) <= 0)
	{
		strcpy_s(modname, "UNKNOWN");
	}

	char * mname = strrchr(modname, '\\');
	(void*)mname++;	 // Remove the last 

	sprintf_s(filename, "CrashDumps\\dump-%s-%u-%u-%u-%u-%u-%u-%u.dmp",	mname, pTime.tm_year+1900, pTime.tm_mon, pTime.tm_mday, pTime.tm_hour, pTime.tm_min, pTime.tm_sec, GetCurrentThreadId());
	
	HANDLE hDump = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0);
	if(hDump == INVALID_HANDLE_VALUE)
	{
		// Create the directory first
		CreateDirectory("CrashDumps", 0);
		hDump = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,	FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0);
	}

	//PrintCrashInformation(pExceptPtrs);
	//printf_s("\nCreating crash dump file %s\n", filename);
	
	if(hDump == INVALID_HANDLE_VALUE)
	{
		//MessageBox(0, "Could not open crash dump file.", "Crash dump error.", MB_OK);
	}
	else
	{
		MINIDUMP_EXCEPTION_INFORMATION info;
		info.ClientPointers		= FALSE;
		info.ExceptionPointers	= pExceptPtrs;
		info.ThreadId			= GetCurrentThreadId();

		MINIDUMP_TYPE mdt = (MINIDUMP_TYPE)(MiniDumpWithFullMemory | 
		                                    MiniDumpWithFullMemoryInfo | 
		                                    MiniDumpWithHandleData | 
		                                    MiniDumpWithThreadInfo | 
		                                    MiniDumpWithUnloadedModules | 
											MiniDumpWithIndirectlyReferencedMemory | MiniDumpWithThreadInfo | MiniDumpWithHandleData);

		MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDump, mdt, (pExceptPtrs != NULL) ? &info : 0, 0, 0);
		CloseHandle(hDump);
	}

	m_crashLock.unlock();
	return EXCEPTION_EXECUTE_HANDLER;
}
Пример #27
0
 decltype (auto)  try_lock() { return mut.try_lock(); }
Пример #28
0
 inline bool lock() { return m_lock.try_lock(); }