Welche Arten und Verwendungen von Sperren gibt es in der C++-Multithread-Programmierung?

Zu den Arten von Sperren in der C++-Multithread-Programmierung gehören: Mutex-Sperren: Stellen Sie sicher, dass jeweils nur ein Thread auf gemeinsam genutzte Ressourcen zugreifen darf. Lese-/Schreibsperren: Erlauben Sie mehreren Threads, gemeinsam genutzte Ressourcen gleichzeitig zu lesen, aber nur Ein Thread kann jeweils auf sie schreiben: Überprüfen Sie ständig den Status der Sperre, um zu vermeiden, dass darauf gewartet wird, dass die Sperre verfügbar ist Art und Zweck der Sperre in der C++-Multithread-Programmierung

Sperre

wird in der Multithread-Programmierung verwendet. Ein wichtiges Werkzeug zum Koordinieren des Thread-Zugriffs auf gemeinsam genutzte Ressourcen. In C++ gibt es mehrere Arten von Sperren, von denen jede ihren eigenen Zweck hat.

1. Mutex-Sperre (Mutex)

Mutex-Sperre ist der einfachste Sperrtyp, der jeweils nur einem Thread den Zugriff auf den kritischen Abschnitt (gemeinsam genutzte Ressource) ermöglicht.

// 创建一个互斥锁
std::mutex mtx;

// 获取互斥锁（线程等待直到锁可用）
mtx.lock();

// 使用临界区
// ...

// 释放互斥锁（允许其他线程获取锁）
mtx.unlock();

2. Lese-/Schreibsperre (RWLock)

Mit der Lese-/Schreibsperre können mehrere Threads gleichzeitig gemeinsam genutzte Ressourcen lesen, aber jeweils nur ein Thread kann schreiben.

// 创建一个读写锁
std::shared_timed_mutex rwmtx;

// 获取读锁（线程可以在其他线程读取时读取）
rwmtx.lock_shared();

// 获取写锁（线程必须独占访问共享资源）
rwmtx.lock();

// 读取或写入临界区
// ...

// 释放锁
rwmtx.unlock();
rwmtx.unlock_shared();

3. Spinlock (Spinlock)

Spinlock ähnelt einer Mutex-Sperre, aber wenn die Sperre nicht verfügbar ist, prüft der Spinlock kontinuierlich den Status der Sperre, anstatt zu warten.

// 创建一个自旋锁
std::atomic_flag spinlock = ATOMIC_FLAG_INIT;

// 获取自旋锁
while (spinlock.test_and_set(std::memory_order_acquire));

// 使用临界区
// ...

// 释放自旋锁
spinlock.clear(std::memory_order_release);

4. Bedingungsvariable

Bedingungsvariable wird verwendet, um auf die Erfüllung einer bestimmten Bedingung zu warten. Es wird in Verbindung mit einer Mutex-Sperre verwendet, um einem Thread zu ermöglichen, zu warten, wenn eine Bedingung nicht erfüllt ist, und den Thread zu wecken, um die Ausführung fortzusetzen.

// 创建一个条件变量
std::condition_variable cv;

// 获取互斥锁
std::mutex mtx;
mtx.lock();

// 等待条件满足
cv.wait(mtx);

// 执行被唤醒后的操作
// ...

// 释放互斥锁
mtx.unlock();

Praktisches Beispiel

Stellen Sie sich eine Anwendung vor, die eine threadsichere Warteschlange enthält. Die Warteschlangenstruktur enthält einen Mutex, der Warteschlangenoperationen schützt.

class Queue {
    private:
        std::queue<int> queue;
        std::mutex mtx;
    public:
        void push(int value) {
            std::lock_guard<std::mutex> lock(mtx);
            queue.push(value);
        }

        int pop() {
            std::lock_guard<std::mutex> lock(mtx);
            int value = queue.front();
            queue.pop();
            return value;
        }
};

In einer Multithread-Umgebung stellt ein Mutex sicher, dass jeweils nur ein Thread auf die Warteschlange zugreifen kann, und verhindert so Datenrennen und Warteschlangenbeschädigung.

Das obige ist der detaillierte Inhalt vonWelche Arten und Verwendungen von Sperren gibt es in der C++-Multithread-Programmierung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!