Có một mutex mở khóa khi nó ra khỏi phạm vi?

Question

Câu hỏi đơn giản - về cơ bản, tôi có phải mở khóa một mutex hay chỉ đơn giản là tôi có thể sử dụng toán tử phạm vi và mutex sẽ tự động mở khóa?

ví dụ:

{ 
    pthread_mutex_lock (&myMutex); 
    sharedResource++; 
} // my mutex is now unlocked? 

hay tôi nên:

{ 
    pthread_mutex_lock (&myMutex); 
    sharedResource++; 
    pthread_mutex_unlock (&myMutex); 
} 

Answer 1

Mutex không nằm ngoài phạm vi trong ví dụ của bạn; và không có cách nào để trình biên dịch biết rằng một hàm cụ thể cần gọi ở cuối phạm vi, vì vậy ví dụ đầu tiên không không phải là mở khóa mutex.

Nếu bạn đang sử dụng (dễ bị lỗi) các chức năng khóa và mở khóa mutex, thì bạn sẽ cần phải đảm bảo rằng bạn luôn gọi unlock() - ngay cả khi thao tác được bảo vệ ném ngoại lệ.

Cách tốt nhất để làm điều này là sử dụng một lớp RAII để quản lý các khóa, như bạn sẽ cho bất kỳ tài nguyên khác mà cần phát hành sau khi sử dụng:

class lock_guard { 
public: 
    explicit lock_guard(mutex & m) : m(m) {mutex_lock(m);} 
    ~lock_guard() {mutex_unlock(m);} 

    lock_guard(lock_guard const &) = delete; 
    void operator=(lock_guard &) = delete; 

private: 
    mutex & m; 
}; 

// Usage 
{ 
    lock_guard lock(myMutex); 
    shared_resource++; 
} // mutex is unlocked here (even if an exception was thrown) 

Trong C hiện đại ++, sử dụng std::lock_guard hoặc std::unique_lock cho điều này.

Answer 2

Sử dụng phương pháp phạm vi RAII là tốt hơn nhiều vì nó đảm bảo rằng các mutex sẽ luôn luôn được mở khóa thậm chí khi đối mặt với trường hợp ngoại lệ hoặc đầu trở về.

Nếu bạn có quyền truy cập vào C++ 11 mặc dù bạn có thể xem xét sử dụng std::atomic<int> thay vào đó trong trường hợp đó bạn không cần phải khóa nó để tăng.

Answer 3

Trong trường hợp này, không có mutex sẽ không được mở khóa khi mã này nằm ngoài phạm vi.

Tủ khóa Mutex sau RAII sử dụng thực tế là trình phá hủy được tự động gọi khi đối tượng được phân bổ không được cấp phát vượt quá phạm vi. Sau đó, nó mở khóa mutex khi đối tượng đã khóa mutex không nằm trong phạm vi. Trong trường hợp mã của bạn, không có đối tượng nào được cấp phát trong phạm vi dấu ngoặc ôm, do đó không có khả năng mở khóa mutex khi phạm vi kết thúc.

Ví dụ, sử dụng QMutexLocker từ các thư viện Qt, bạn có thể đảm bảo rằng mutex bạn được mở khóa khi phạm vi được kết thúc:

{ 
    QMutexLocker locker(myMutex); 
    if(checkSomething()) 
    { 
     return; 
    } 
    doSomething(); 
} 

Mã này cũng tương tự như:

{ 
    mutex_lock(myMutex); 
    if(checkSomething()) 
    { 
     mutex_unlock(myMutex); 
     return; 
    } 
    doSomething(); 
    mutex_unlock(myMutex); 
} 

Mặc dù như Brian Neal chỉ ra, nó không xử lý an toàn trường hợp các trường hợp ngoại lệ là checkSomething() và doSomething().

Cách thay thế cho Qt's QMutexLocker sẽ là số std::lock_guard của STD.