C++ mutex::unlock方法代码示例

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

// Thread to import data from the USRP !Size of the arrays in complex -> 2*buffer_size !
void usrpGetData(uhd::rx_streamer::sptr rx_stream, uhd::usrp::multi_usrp::sptr dev, size_t buffer_size, board_60GHz_RX *my_60GHz_RX){
  // Set priority of the thread
  int which = PRIO_PROCESS;
  id_t pid;
  int priority = -20;
  int ret;

  pid = getpid();
  ret = setpriority(which, pid, priority);
  if(ret!=0){  std::cout << "Main priority went wrong in usrpT: " << ret << std::endl ;}

  // Create storage for a single buffer from USRP
  short *buff_short;
  buff_short=new short[2*buffer_size]; 

 
  size_t n_rx_last;
  uhd::rx_metadata_t md;
  //int time=buffer_size/(25)-100; // microsecondes

  while (1){
    n_rx_last=0;

    // Fill buff_short
    while (n_rx_last==0) {
      n_rx_last=rx_stream->recv(&buff_short[0], buffer_size, md, 3.0);
      std::this_thread::yield(); // Avoid active waiting
    };

    // Check if no overflow
    if (n_rx_last!=buffer_size) {
      std::cerr << "I expect the buffer size to be always the same!\n";
      std::cout<<"Read only:"<<n_rx_last<<"\n";
      std::cout<<"Buffer:"<<buffer_size<<"\n";
      //exit(1); 
    }else{

    // Add the just received buffer to the queue
    mtxUsrp.lock();
    usrpQ.push(buff_short);
    mtxUsrp.unlock();
    // Change memory cell used
    buff_short=new short [2*buffer_size];

    // Gives the start to detection part
    sem_post( &usrpReady); 
    }

  }//end while 1
}

void send_logs()
{
  static std::mutex mtx;
  
  mtx.lock();

  Logger::LogPath lp;
  
  const std::map<string, string> logs=
  {
    { lp.errorLogFile, serverLogPath + "/Errors/"},
    { lp.infoLogFile, serverLogPath + "/Info/"},
    { lp.productLogFile, serverLogPath + "/Products/"}
  };
  
  WebClient::FTP ftp;
  
  for (auto itr = logs.begin(); itr != logs.end(); ++itr)
  {
    if (Utils::file_exists(itr->first))
    {
      const string logPath = itr->first + ".copy";
      if (!Utils::copy_paste_file(itr->first, logPath))
	break;
      
      size_t found = itr->first.find_last_of("/\\");
      
      if (found != string::npos)
      {
	const string fileName = itr->first.substr(found+1);
	
	for (int i = 0; i < 2; i++)
	{
	  if (!ftp.upload_file(logPath, itr->second, ftpCredentials, fileName))
	  {
	    cout << "Failed to upload file to ftp server!" << endl;
	    usleep(ONESECOND / 2);
	    continue;
	  }
	  break;
	}  
      }
      else
	cout << "Invalid filepath: " << itr->first << endl;
      
      delete_temp_logs();
    }
  }
  mtx.unlock();
}

 void operator() ()
 {
   for (int i = start_; i <= end_; ++i)
     for (int j = 0; j < columns_; ++j)
     {
       char current = matrix_[i][j];
       if ((current >= 'a') && (current <= 'j'))
       {
         mtx.lock();
         ++(*result_)[current - 'a'];
         mtx.unlock();
       }
     }
 }

 inline void _removeToken(const std::string& path)
 {
     auto preCheck = m_tokens.find(path);
     if (preCheck != m_tokens.end())
     {
         DeviceToken& tok = *preCheck->second;
         std::shared_ptr<DeviceBase> dev = tok.m_connectedDev;
         tok._deviceClose();
         deviceDisconnected(tok, dev.get());
         m_tokensLock.lock();
         m_tokens.erase(preCheck);
         m_tokensLock.unlock();
     }
 }

bool FileWriter::write()
{
	mtx.lock();
	while (loadAvail == false)
	{   
		mtx.unlock();
		usleep(100*5);
		mtx.lock();
	}   
	loadAvail = false;
	mtx.unlock();
	if(fs.is_open() && fs.good())
	{
		fs.write(writeBuffer, toWrite);
	}
	mtx.lock();
	loadAvail = true;
	mtx.unlock();

	if (fs.bad())
		return false;
	return true;
}

void ImageLoader::AddToPending(const char* Filename)
{
    UploadData New;
    if (Textures.find(Filename) == Textures.end())
    {
        auto d = GetDataForImage(Filename);
        New.Data = d.Data;
        New.Width = d.Width;
        New.Height = d.Height;
        LoadMutex.lock();
        PendingUploads.insert(std::pair<char*, UploadData>((char*)Filename, New));
        LoadMutex.unlock();
    }
}

 bool dequeue(T* data)
 {
     head_mutex.lock();
     
     node* current_head = head;
     node* new_head = current_head->next;
     
     if( new_head == nullptr)
     {
         head_mutex.unlock();
         return false;
     }
     
     *data = new_head->data;
     
     head = new_head; // Swapping dummy-initial node so we avoid to update the tail pointer
                      // Therefore no need for protecting the tail
     
     head_mutex.unlock();
     
     delete current_head; // De allocate previous dummy node
     return true;
 }

void randomCalculate(int size, char ch) {
  mutex.lock();  // enter critical section
  for (int i = 0; i < size; ++i) {
    int numerator = rand() % 10;
    int denominator = rand() % 10;
    if (denominator == 0) {
      throw DivisionByZeroException();
    }
    float quotient = static_cast<float>(numerator) / denominator;
    printf(" %c%i/%i=%.2f%c ", ch, numerator, denominator, quotient, ch);
  }
  printf("\n\n");
  mutex.unlock();  // exit critical section
}

        virtual void show_image() {

            // get the next element inside the CircularBuffer
            cv::Mat frame = input.first.pop();

            if (!frame.empty()) {

                item->setPixmap(QPixmap::fromImage(QImage(frame.data, frame.cols, frame.rows, QImage::Format_RGB888).rgbSwapped()));

            }

            img_view_mutex.unlock();

        }

void running(void * aArg) {
	wmra _wmra;

	_wmra.initialize();

	clock_t last_time, current_time;
	last_time = clock()-1;
	current_time = clock();
	double dt;
	int count = 0;

	vector<double> X_dot;
	for (int i = 0; i < 7; i++)
	{
		X_dot.push_back(0.0);
		_wmra.Qarm.push_back(0.0);
	}

	_wmra.sendInputValues(); // zero input

	while (true)
	{
		/****Calculate dt****/
		clock_t current_time = clock();
		dt = (current_time - last_time) / CLOCKS_PER_SEC;
		last_time = current_time;
		/********************/

		/****Data Output (cout)****/
		std::cout.flush();
		std::cout << "\rRunning at " << 1/dt << " seconds per loop" << std::endl;
		std::cout << "Omni Input = [" << _wmra.inputDevice[0] << ", " << _wmra.inputDevice[1] << ", " << _wmra.inputDevice[2] << "]" << std::endl;		
		/********************/

		m.lock(); // mutex locked since using global variable.
		_wmra.sendInputValues(inputValues); 
		m.unlock();

		_wmra.Jacobian_Ground2Endeffector();
		_wmra.weighted_pseudoinverse();
		_wmra.control_joint(_wmra.inputDevice[4], _wmra.inputDevice[5]);
		_wmra.sendInputValues(); // zero input values after they are used

		/**********Updating Devices**********/
		_wmra.ARM.updateArmPosition();
		_wmra.WHEELCHAIR.WMRA_Theta_dot2Xphi_dot();
		_wmra.phi = _wmra.phi + _wmra.WHEELCHAIR.DXphi_dot[1];
		/********************/
	}
}

void threadfunction_sleep_mutex_try_lock(int arg) 
{
  this_thread::sleep_for (std::chrono::milliseconds(200));
  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++;
    }
  }
}

void GHtttpService::request(GHttpTask* task)
{
    CURL* handle = this->getHandle(task);
    
    mutex.lock();
    this->handle_list.push_back(handle);
    mutex.unlock();
    
    auto success = curl_easy_perform(handle);
    
    mutex.lock();
    long retcode = 0;
    curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE , &retcode);

    if(success == CURLE_OK && retcode == 200)
    {
        task->setStatus(true);
        GLog("http request:%s ok",task->getUrl().c_str());
    }
    else
    {
        GLogE("http request:%s failure",task->getUrl().c_str());
    }
    if(task->getType() == GHTTPTYPE::DOWNLOAD)
    {
        task->closeFile();
        if(task->getAsync())//只有异步时才release
            task->release();
    }
    this->removeHandle(handle);
    mutex.unlock();
    
    if(task->callback)
    {
        task->callback(task->getUrl(),task->getStatus());
    }
}

int main() {
    // Это вектор потоков.
    std::vector<std::thread> threads;


    // Запускаем все наши потоки
    for (int i = 0; i < threadsNumber; ++i) {
        threads.push_back(std::thread(threadFunc, i));
    }


    // Этот блок кладёт задания в нашу очередь.
    unsigned i = 1;
    while (i++ < 10000) {

        // Сгенерируем два случайных числа.
        std::random_device rd;   // non-deterministic generator
        std::mt19937 gen(rd());
        long long k =  static_cast<long long>(abs(gen())) % 102;
        long long k1 =  static_cast<long long>(abs(gen())) % 102;

        // Сунем эти два числа в блокирующую очередь.
        writeMutex.lock();
        std::cout << "k == " << k  << " given " << std::endl;
        std::cout << "k1 == " << k1  << " given " << std::endl;
        writeMutex.unlock();

        ourQueue.enqueue(k);
        ourQueue.enqueue(k1);
    }
/*
    // Запускаем все наши потоки
    for (int i = 0; i < threadsNumber; ++i) {
        threads.push_back(std::thread(threadFunc, i));
    }
*/
    // Бросим ядовитые пилюли, чтобы убить потоки.
    for (int i = 0; i < threadsNumber; ++i)
        ourQueue.enqueue(-1);


    // Ждём пока все потоки завершатся.
    for (int j = 0; j < threadsNumber; ++j) {
        if (threads[j].joinable())
            threads[j].join();
    }

    return 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);
	}
}