C++11 多線程 Mutex篇 （續)

Mutex篇續

上一篇傳送門

 

std::unique_lock::try_lock_until

template<typename Clock, typename Duration>
 bool try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time);

嘗試調用unique_lock所管理的對象(注:該對象也必須支持try_lock_until)的try_lock_until(abs_time)給所管理的互斥量上鎖.

(注：try_lock_until函數接受一個時間點(abs_time)做爲參數.在指定的時間點到來以前當前線程中的unique_lock管理的mutex未得到線程鎖，那麼當前線程就會被阻塞(blocking),若是在到達時間點以前爲能給所管理的互斥量上鎖那麼返回false.上鎖了就返回true.)

 

std::unique_lock::unlock

void unlock();

調用被管理的mutex的unlock()函數，解鎖被管理的mutex,並把unique_lock對該mutex的擁有權設置爲false.

 

std::unique_lock::relase

mutex_type* relase()noexcept;

該函數返回被unique_lock管理的mutex對象的指針，再也不擁有該mutex的管理權，若是該mutex在被unique_lock管理的時候被上鎖了，該mutex被relase出來的時候仍然是lock的，須要被unlock.

 // unique_lock::release example
#include <iostream>       // std::cout
#include <vector>         // std::vector
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock

std::mutex mtx;
int count = 0;

void print_count_and_unlock (std::mutex* p_mtx) {
  std::cout << "count: " << count << '\n';
  p_mtx->unlock();
}

void task() {
  std::unique_lock<std::mutex> lck(mtx);
  ++count;
  print_count_and_unlock(lck.release()); //因爲前面已經用unique_lock對mtx上鎖了縱然釋放了對mtx的全部權，mtx仍然是被鎖住的. 
}

int main ()
{
  std::vector<std::thread> threads;
  for (int i=0; i<10; ++i)
    threads.emplace_back(task); //注意這裏的emplace_back.

  for (auto& x: threads) x.join();

  return 0;
}

 

std::unique_lock::owns_lock

bool owns_lock()noexcept;

若是當前unique_lock管理的muex，被當前的unique_lock上鎖了那麼返回true,其餘返回false.

 

#include <iostream>       // std::cout
#include <vector>         // std::vector
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock, std::try_to_lock

std::mutex mtx;           // mutex for critical section

void print_star () {
  std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
  // print '*' if successfully locked, 'x' otherwise: 
  if (lck.owns_lock())
    std::cout << '*';
  else                    
    std::cout << 'x';
}

int main ()
{
  std::vector<std::thread> threads;
  for (int i=0; i<500; ++i)
    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return 0;
}

 std::unique_lock::operator bool()

explicit operator bool()noexcept;

若是當前unique_lock管理的mutex對象被上鎖了，返回true,不然返回false.

 #include <iostream>       // std::cout
#include <vector>         // std::vector
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock, std::try_to_lock

std::mutex mtx;           // mutex for critical section

void print_star () {
  std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
  // print '*' if successfully locked, 'x' otherwise: 
  if (lck)
    std::cout << '*';
  else                    
    std::cout << 'x';
}

int main ()
{
  std::vector<std::thread> threads;
  for (int i=0; i<500; ++i)
    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return 0;
}

 

std::unique_lock::mutex

 mutex_type* mutex()noexcept;

返回一個指針指向當前unique_lock管理的mutex對象。

可是unique_lock仍然擁有mutex的全部權，當unique_lock析構的時候mutex對象被解鎖.

 

補充:

lock_guard (mutex_type& m, adopt_lock_t tag);

 在lock_gurad的構造函數中，能夠接受一個標籤:

std::adpot_lock

該標籤意味着當前線程中的互斥量(mutex)，已經被當前線程上過鎖了，如今lock_guard來接手管理.

 

unique_lock (mutex_type& m, try_to_lock_t tag);

unique_lock (mutex_type& m, defer_lock_t tag) noexcept;

unique_lock (mutex_type& m, adopt_lock_t tag);

在unique_lock的構造函數中,能夠接受三個標籤:

std::try_to_lock //調用所管理的muetx的try_lock函數給當前線程內的管理的當前mutex上鎖.

std::defer_lock//延遲上鎖，雖然接手了mutex可是並無給它上鎖.須要後續的上鎖操做.

std::adopt_lock//當前線程已經對mutex上鎖過了，如今unique_lock來接手管理。