C++ 11 interprocess atomics và mutexes

Question

Tôi có một chương trình Linux để sinh ra một số quy trình (fork) và giao tiếp thông qua POSIX Shared Memory. Tôi muốn có mỗi quá trình phân bổ một id (0-255). Ý định của tôi là đặt một bitvector trong khu vực bộ nhớ chia sẻ (khởi tạo bằng không) và nguyên tử so sánh và trao đổi một chút để phân bổ một id.

Có cách nào thân thiện với C++ 11 để thực hiện việc này không? Tôi có thể tạo một bitet nguyên tử không? Tôi có thể sử dụng mutex trên các quy trình không? Làm cách nào để đảm bảo rằng các nhà xây dựng được gọi một lần và chỉ một lần trên tất cả các quy trình?

Answer 1

C++ 11 luồng nguyên thủy (mutexes, atomics, v.v.) là luồng nguyên thủy. Họ không biết gì về quy trình, và họ không phải là phương tiện để đạt được giao tiếp giữa các quá trình.

Vì tiêu chuẩn C++ 11 không đề cập đến các quy trình hoặc giao tiếp giữa các quá trình, hành vi của các nguyên thủy như vậy khi được đặt trong bộ nhớ chia sẻ quy trình (một tệp ánh xạ bộ nhớ, một số loại ngoài quy trình bộ nhớ được ánh xạ, vv) là không xác định.

Answer 2

Bạn có thể sử dụng mutex bên trong khối bộ nhớ chia sẻ, nhưng mutex phải được khai báo là chia sẻ, do đó không phải là bất thường sử dụng mutexes bên trong chia sẻ bộ nhớ, u có thể làm cho lớp riêng, nó rất đơn giản:

class Mutex { 
private: 
    void *_handle; 
public: 
    Mutex(void *shmMemMutex, bool recursive =false,); 
    virtual ~Mutex(); 

    void lock(); 
    void unlock(); 
    bool tryLock(); 
}; 

Mutex::Mutex(void *shmMemMutex, bool recursive) 
{ 
    _handle = shmMemMutex; 
    pthread_mutexattr_t attr; 
    ::pthread_mutexattr_init(&attr); 
    ::pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); 
    ::pthread_mutexattr_settype(&attr, recursive ? PTHREAD_MUTEX_RECURSIVE_NP : PTHREAD_MUTEX_FAST_NP); 

    if (::pthread_mutex_init((pthread_mutex_t*)_handle, &attr) == -1) { 
     ::free(_handle); 
     throw ThreadException("Unable to create mutex"); 
    } 
} 
Mutex::~Mutex() 
{ 
    ::pthread_mutex_destroy((pthread_mutex_t*)_handle); 
} 
void Mutex::lock() 
{ 
    if (::pthread_mutex_lock((pthread_mutex_t*)_handle) != 0) { 
     throw ThreadException("Unable to lock mutex"); 
    } 
} 
void Mutex::unlock() 
{ 
    if (::pthread_mutex_unlock((pthread_mutex_t*)_handle) != 0) { 
     throw ThreadException("Unable to unlock mutex"); 
    } 
} 
bool Mutex::tryLock() 
{ 
    int tryResult = ::pthread_mutex_trylock((pthread_mutex_t*)_handle); 
    if (tryResult != 0) { 
     if (EBUSY == tryResult) return false; 
     throw ThreadException("Unable to lock mutex"); 
    } 
    return true; 
}