互斥锁 QMutex Class 的翻译

互斥锁 QMutex Class 的翻译

简介
互斥锁的存在是为了保证线程间的访问资源的连续性。该资源可以是一个对象（object），数据结构（data structure），或者一段代码（ a section of code），并且保证同一时间只能有一个线程来访问。

举个列子：

int number = 6;

void method1()
{
    number *= 5;
    number /= 4;
}

void method2()
{
    number *= 3;
    number /= 2;
}

如果，上述的方法在按次序访问时候，那么结果的变化如下：

// method1()
number *= 5;        // number is now 30
number /= 4;        // number is now 7

// method2()
number *= 3;        // number is now 21
number /= 2;        // number is now 10

如果，同时被两个线程访问，结果可能会变得糟糕：

// Thread 1 calls method1()
number *= 5;        // number is now 30

// Thread 2 calls method2().
//
// Most likely Thread 1 has been put to sleep by the operating
// system to allow Thread 2 to run.
number *= 3;        // number is now 90
number /= 2;        // number is now 45

// Thread 1 finishes executing.
number /= 4;        // number is now 11, instead of 10

如果我们使用互斥锁：

QMutex mutex;
int number = 6;

void method1()
{
    mutex.lock();
    number *= 5;
    number /= 4;
    mutex.unlock();
}

void method2()
{
    mutex.lock();
    number *= 3;
    number /= 2;
    mutex.unlock();
}

这样就可以保证只有一个线程在给定的时间内使用，这样就可以保证结果的准确性。

如果线程1已经ock()，线程2也尝试lock()，那么线程2将阻塞，知道线程2解锁为止。

使用方法：

Header: #include
qmake: QT += core
Inherits: QBasicMutex
Inherited By:
QRecursiveMutex

Public Types
enum RecursionMode { Recursive, NonRecursive }

Public Functions
QMutex(QMutex::RecursionMode mode)
QMutex()
~QMutex()
bool isRecursive() const
void lock()
bool tryLock(int timeout = 0)
bool try_lock()
bool try_lock_for(std::chrono::duration<Rep, Period> duration)
bool try_lock_until(std::chrono::time_point<Clock, Duration> timePoint)
void unlock()

成员介绍：

enum QMutex::RecursionMode

QMutex::Recursive 值1
在该模式下，一个线程可以加锁多次，这个互斥关系将一直保持，知道所加锁都被解锁为止。

QMutex::NonRecursive 值 0
该模式下，只有一把锁

函数成员：
1、
void QMutex::unlock()
解锁。如果在去解锁另外一个线程的锁将会出错。如果为上锁，而去解锁，也会出错。
2、
bool QMutex::try_lock_until(std::chrono::time_point<Clock, Duration> timePoint)

尝试上锁。当获得锁的时候，返回为真。反之，返回为负。
如果另外一个线程加了锁，那么该线程会一直等到timePoint 时间点为止。

注意，调用该函数的时候，如果已经过了该时间点，就等同于函数try_lock（）；
3、
bool QMutex::try_lock_for(std::chrono::duration<Rep, Period> duration)
尝试上锁。当获得锁的时候，返回为真。反之，返回为负。
如果另外一个线程加了锁，那么该线程会一直等，等待是时间间隔为duration;

注意：如果该时间间隔为负，等同于函数try_lock();

4、
bool QMutex::try_lock()
尝试上锁。当获得锁的时候，返回为真。反之，返回为负。
等同于tryLock();

5、
bool QMutex::tryLock(int timeout = 0)
尝试上锁。当获得锁的时候，返回为真。反之，返回为负。
如果另一个线程已加锁，那么该线程为等待（timeout 微妙）直到该锁可以被该线程上锁为止。

注意：如果timeout 为负数 ，等同于lock()，那么表示会一直等，一直可以上锁为止。

如果该线程上了锁，那么只能有该线程来解锁。

6、
void QMutex::lock()
上锁。如果线程2已经上锁了，那么线程1会一直阻塞直到线程2解锁为止。

7、
QMutex::QMutex(QMutex::RecursionMode mode)
创建锁。默认是未上锁的状态。
该函数表示可以上多次锁。

8、
QMutex::QMutex()
创建锁。默认是未上锁的状态。默认为QMutex::NonRecursive.

9、
QMutex::~QMutex()
销毁锁

10、
bool QMutex::isRecursive() const
返回是否是recursive. 模式。

本篇翻译完毕。

总结：

该类的描述还是很简单清楚明了的。

本人也尝试写了一篇应用，供读者们参考：互斥锁的简单应用