QMutex

原创已于 2025-03-05 11:04:04 修改 · 1.1k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-03-02 15:12:02 首次发布

qt-线程专栏收录该内容

41 篇文章

订阅专栏

1.概要

2.内容

QMutex是Qt框架中提供的一个互斥锁类，用于保护共享数据不被多个线程同时修改，从而避免数据竞争和不一致性问题。

QMutex的基本概念和用途

概念：QMutex类提供线程间的访问序列化，确保在同一时间只有一个线程可以访问被保护的资源。它类似于Java中的synchronized关键字或C++11中的std::mutex。
用途：在多线程编程中，多个线程可能会同时访问和修改共享资源，这可能导致数据不一致或竞争条件。QMutex通过互斥锁机制，确保同一时间只有一个线程能够访问和修改共享资源，从而保护数据的一致性和完整性。

QMutex的主要成员函数

lock()：试图锁定互斥量。如果另一个线程已经锁定了这个互斥量，调用线程将被阻塞，直到那个线程解锁。
unlock()：解锁互斥量，允许其他线程锁定它。
tryLock()：尝试锁定互斥量，不阻塞调用线程。如果互斥量被锁定，函数返回false；如果成功锁定，返回true。
tryLock(int timeout)：尝试在指定的毫秒数内锁定互斥量。如果超时仍未锁定，返回false；如果成功锁定，返回true。
locked()：查询互斥量当前是否被锁定。如果被锁定，返回true；否则返回false。

QMutex的使用示例

以下是一个简单的示例，演示如何使用QMutex保护共享数据：

#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QDebug>

class SharedData {
public:
    SharedData() : value(0) {}

    void increment() {
        QMutexLocker locker(&mutex);  // 自动锁定互斥量
        ++value;
        qDebug() << "Value incremented to" << value << "by thread" << QThread::currentThread();
    }

    int getValue() const {
        QMutexLocker locker(&mutex);  // 自动锁定互斥量
        return value;
    }

private:
    mutable QMutex mutex;
    int value;
};

class WorkerThread : public QThread {
    Q_OBJECT

public:
    WorkerThread(SharedData *data, QObject *parent = nullptr)
        : QThread(parent), sharedData(data) {}

protected:
    void run() override {
        for (int i = 0; i < 10; ++i) {
            sharedData->increment();
            QThread::sleep(1);  // 模拟一些工作
        }
    }

private:
    SharedData *sharedData;
};

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    SharedData sharedData;
    WorkerThread thread1(&sharedData);
    WorkerThread thread2(&sharedData);

    thread1.start();
    thread2.start();

    thread1.wait();
    thread2.wait();

    qDebug() << "Final value is" << sharedData.getValue();

    return a.exec();
}

QMutex与QMutexLocker

QMutexLocker：是一个辅助类，用于简化对QMutex的锁定和解锁操作。它基于RAII（Resource Acquisition Is Initialization）机制，在构造时自动锁定互斥量，在析构时自动解锁。这种方式确保了即使在发生异常或函数提前返回的情况下，互斥量也能被正确解锁，从而避免了死锁的风险。
使用场景：在简单的函数中，可以直接使用QMutex的lock()和unlock()成员函数。但在复杂的函数或异常处理代码中，使用QMutexLocker更为安全和方便。

注意事项

避免死锁：在使用QMutex时，要注意避免死锁的发生。死锁通常发生在两个或多个线程相互等待对方释放互斥量时。为了避免死锁，应确保线程以相同的顺序获取互斥量。
性能考虑：互斥量的锁定和解锁操作是有开销的。因此，应尽量减少锁的持有时间，避免在锁定的代码块中执行耗时操作。
可重入性：如果类的方法需要在持有锁的情况下被多次调用（例如递归调用），应考虑使用可重入的锁机制或设计无锁算法。

总结

QMutex是Qt框架中用于实现线程同步的重要工具。通过合理使用QMutex，可以保护共享资源不被多个线程同时修改，从而避免数据竞争和不一致性问题。在复杂的线程同步场景中，可以结合使用QMutex和QMutexLocker等类，以确保线程的安全运行。

3.关联链接

c++ 线程同步的临界区应用举例

c++线程同步应用，简单举例

c++ 线程同步的手段有多少

4.关联知识

1.tryLock

tryLock是QMutex类提供的一个成员函数，用于尝试锁定互斥量，而不会阻塞调用线程。以下是对tryLock的详细解释：

功能描述

tryLock尝试锁定一个互斥量。如果互斥量当前未被锁定，tryLock会立即锁定互斥量，并返回true；如果互斥量已经被其他线程锁定，tryLock会立即返回false，而不会使调用线程进入阻塞状态。

使用场景

非阻塞锁定：在某些情况下，线程可能希望在无法立即获取锁时继续执行其他任务，而不是等待锁被释放。这时可以使用tryLock来尝试锁定互斥量，如果锁定失败，则执行其他任务或稍后重试。
性能优化：在需要高并发性能的场景中，频繁的锁等待可能导致性能下降。使用tryLock可以减少锁的等待时间，提高程序的响应速度。

使用方法

QMutex mutex;

if (mutex.tryLock()) {
    // 锁定成功，访问共享资源
    // ...
    mutex.unlock();  // 访问完成后解锁
} else {
    // 锁定失败，执行其他操作或稍后重试
    // ...
}

注意事项

解锁操作：如果tryLock返回true，表示互斥量已被成功锁定，调用线程必须在访问完共享资源后调用unlock来解锁互斥量，以便其他线程能够访问共享资源。
递归锁定：如果互斥量是以递归模式创建的（即QMutex::Recursive），则同一个线程可以多次调用tryLock来锁定互斥量，但每次锁定操作都必须有相应的解锁操作来匹配。
避免死锁：尽管tryLock不会使线程进入阻塞状态，但在多线程编程中仍然需要注意避免死锁的发生。确保线程以合理的顺序请求锁，并避免循环等待锁的情况。

与`lock`的区别

lock函数会阻塞调用线程，直到互斥量被成功锁定。这意味着如果互斥量当前被其他线程锁定，调用线程将等待直到锁被释放。
tryLock函数不会阻塞调用线程，而是立即返回锁定操作的结果。如果互斥量当前被其他线程锁定，tryLock会返回false，调用线程可以继续执行其他任务。

总结

tryLock是QMutex类提供的一个非常有用的函数，它允许线程以非阻塞的方式尝试锁定互斥量。在多线程编程中，合理使用tryLock可以提高程序的并发性能和响应速度。然而，使用tryLock时也需要注意解锁操作和避免死锁等问题。

2.lock()和tryLock()的用法差异，前者能锁上就继续运行，要不就等，后者是能锁上运行A,否则运行B

lock() 和 tryLock() 是 Java 中用于线程同步的锁机制的一部分，通常用于 ReentrantLock 类。它们的主要区别在于获取锁的方式以及在无法立即获取锁时的行为。

`lock()`

行为: lock() 方法用于获取锁。如果锁不可用，则当前线程将等待直到锁可用。
用法: 适用于需要确保在锁可用之前线程不继续执行的场景。
特点:
- 阻塞：如果锁已被其他线程持有，调用 lock() 的线程将被阻塞，直到锁被释放。
- 无超时：lock() 没有提供超时机制，线程可能会无限期地等待。

`tryLock()`

行为: tryLock() 方法尝试获取锁。如果锁可用，则立即获取锁并返回 true。如果锁不可用，则立即返回 false，而不会阻塞线程。
用法: 适用于希望在无法获取锁时继续执行其他操作的场景。
特点:
- 非阻塞：不会等待锁释放。
- 灵活性：允许程序决定在无法获取锁时执行其他逻辑。

`tryLock(long timeout, TimeUnit unit)`

这是一个带超时的重载版本，它尝试在指定的时间范围内获取锁。如果在超时时间内获取到了锁，则返回 true，否则返回 false。

示例代码

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void withLock() {
        lock.lock();
        try {
            // 执行需要锁保护的代码
            System.out.println("Lock acquired with lock()");
        } finally {
            lock.unlock();
        }
    }

    public void withTryLock() {
        if (lock.tryLock()) {
            try {
                // 执行需要锁保护的代码
                System.out.println("Lock acquired with tryLock()");
            } finally {
                lock.unlock();
            }
        } else {
            // 如果无法获取锁，执行其他操作
            System.out.println("Could not acquire lock with tryLock()");
        }
    }
    
    public void withTryLockTimeout() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                try {
                    // 执行需要锁保护的代码
                    System.out.println("Lock acquired with tryLock(timeout)");
                } finally {
                    lock.unlock();
                }
            } else {
                // 超时后执行的操作
                System.out.println("Could not acquire lock within timeout");
            }
        } catch (InterruptedException e) {
            // 处理中断
            Thread.currentThread().interrupt();
        }
    }
}

总结

使用 lock() 时，线程会等待直到锁可用。
使用 tryLock() 时，线程会尝试获取锁，如果失败则可以继续执行其他操作。
选择使用哪种方法取决于应用程序在锁不可用时的需求和行为模式。

3.阻塞和非阻塞的差异

阻塞和非阻塞是计算机编程中，特别是在处理输入/输出（I/O）操作时常用的概念，它们描述了程序在等待操作完成时的行为方式。以下是阻塞和非阻塞的主要差异：

1. 定义与行为

阻塞（Blocking）：
- 定义：当一个操作（如文件读取、网络请求等）需要等待某个条件完成才能继续执行时，如果当前线程选择等待这个条件完成，那么该线程就被认为是阻塞的。
- 行为：在阻塞状态下，线程会暂停执行，释放CPU资源，直到等待的条件满足（如数据准备好、资源可用等），线程才会被唤醒并继续执行。
非阻塞（Non-Blocking）：
- 定义：当一个操作不能立即完成时，如果当前线程不会等待该操作完成，而是继续执行其他任务，那么该线程就被认为是非阻塞的。
- 行为：在非阻塞状态下，线程会立即返回，不会等待操作完成。程序通常会通过轮询、事件通知或回调机制等方式来检查操作是否完成。

2. 资源使用与效率

阻塞：
- 资源使用：阻塞线程会占用系统资源（如CPU时间片、内存等），但在等待期间并不执行任何有用的工作。
- 效率：由于线程在等待期间不执行任何操作，因此程序的整体效率可能会受到影响，特别是在I/O密集型应用中。
非阻塞：
- 资源使用：非阻塞线程在等待操作完成时不会占用CPU资源，可以继续执行其他任务，从而提高系统的资源利用率。
- 效率：非阻塞模型通常能提高程序的响应速度和吞吐量，特别是在需要处理大量并发请求的应用中。

3. 编程复杂度

阻塞：
- 复杂度：阻塞编程模型相对简单，易于理解和实现。程序员通常不需要处理复杂的并发逻辑和状态管理。
非阻塞：
- 复杂度：非阻塞编程模型需要程序员处理更多的并发逻辑和状态管理。例如，需要实现轮询机制、事件通知或回调机制来检查操作是否完成。此外，还需要注意避免竞态条件和死锁等问题。

4. 应用场景

阻塞：
- 适用场景：适用于简单应用或性能要求不高的场景。例如，在单线程或少量并发请求的情况下，阻塞模型可能是一个可行的选择。
非阻塞：
- 适用场景：适用于需要处理大量并发请求、对性能要求较高的场景。例如，在服务器、网络通信、实时系统等领域中，非阻塞模型通常是一个更好的选择。

5. 示例

阻塞示例：

import java.io.*;

public class BlockingExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，readLine() 方法是阻塞的。如果文件尚未准备好读取，线程将被阻塞，直到数据可用。

非阻塞示例：

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public class NonBlockingExample {
    public static void main(String[] args) {
        try (FileChannel fileChannel = new FileInputStream("file.txt").getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (fileChannel.read(buffer) != -1) {
                buffer.flip();
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get());
                }
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，FileChannel.read() 方法是非阻塞的。即使文件尚未准备好读取，线程也不会被阻塞，而是会继续执行循环中的其他代码。