目录
?
QSemaphoreQSemaphore提供了一种计数信号量机制，可以用于控制对共享资源的访问。
#include <QCoreApplication>
#include <QThread>
#include <QSemaphore>
#include <QDebug>
class Producer : public QThread
{
public:
Producer(QSemaphore *freeBytes, QSemaphore *usedBytes)
: m_freeBytes(freeBytes), m_usedBytes(usedBytes) {}
void run() override {
for (int i = 0; i < 10; ++i) {
m_freeBytes->acquire(); // 获取free区域大小
qDebug() << objectName() << "Producer produced data";
m_usedBytes->release(); // 更新Used区域大小
sleep(1); // 模拟耗时操作
}
}
private:
QSemaphore *m_freeBytes;
QSemaphore *m_usedBytes;
};
class Consumer : public QThread
{
public:
Consumer(QSemaphore *freeBytes, QSemaphore *usedBytes)
: m_freeBytes(freeBytes), m_usedBytes(usedBytes) {}
void run() override {
for (int i = 0; i < 10; ++i) {
m_usedBytes->acquire(); // 获取Used区域大小
qDebug() << objectName() << "Consumer consumed data";
m_freeBytes->release(); // 更新Free区域大小
sleep(1); // 模拟耗时操作
}
}
private:
QSemaphore *m_freeBytes;
QSemaphore *m_usedBytes;
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QSemaphore freeBytes(10); // 初始化Free区域大小为10
QSemaphore usedBytes(0); // 初始化Used区域大小为0
Producer producer(&freeBytes, &usedBytes);
Producer producer1(&freeBytes, &usedBytes);
Consumer consumer(&freeBytes, &usedBytes);
Consumer consumer1(&freeBytes, &usedBytes);
Consumer consumer2(&freeBytes, &usedBytes);
producer.setObjectName("producer");
producer1.setObjectName("producer1");
consumer.setObjectName("consumer");
consumer1.setObjectName("consumer1");
consumer2.setObjectName("consumer2");
producer.start();
producer1.start();
consumer.start();
consumer1.start();
consumer2.start();
producer.wait();
producer1.wait();
consumer.wait();
consumer1.wait();
consumer2.wait();
return a.exec();
}????????创建了一个生产者和一个消费者线程。生产者线程负责生成数据，消费者线程负责消费数据。通过使用QSemaphore来控制对共享资源的访问，确保生产者和消费者线程能够正确地同步执行。生产者线程在每次生成数据之前，会先获取freeBytes信号量，表示可用的Free区域大小；然后释放usedBytes信号量，表示已使用的Used区域大小。消费者线程在每次消费数据之前，会先获取usedBytes信号量，表示已使用的Used区域大小；然后释放freeBytes信号量，表示可用的Free区域大小。通过这种方式，我们实现了多线程之间的同步和通信。
#include <QCoreApplication>
#include <QMutex>
#include <QMutexLocker>
#include <QDebug>
#include <QThread>
class SharedResource
{
public:
void accessResource() {
QMutexLocker locker(&mutex);
// 访问共享资源
qDebug() << "Accessing shared resource"<<--a;
}
int a;
private:
QMutex mutex; // 互斥锁
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
SharedResource resource;
resource.a = 10;
// 多个线程访问共享资源
QThread thread1, thread2;
QObject::connect(&thread1, &QThread::started, [&](){ resource.accessResource(); });
QObject::connect(&thread2, &QThread::started, [&](){ resource.accessResource(); });
thread1.start();
thread2.start();
thread1.wait();
thread2.wait();
return a.exec();
}
定义了一个SharedResource类，它包含一个访问共享资源的成员函数accessResource。为了保护对共享资源的访问，我们在函数内部使用了QMutexLocker。QMutexLocker是一个RAII（Resource Acquisition Is Initialization）风格的锁管理类，它会在构造函数中自动获取互斥锁，并在析构函数中自动释放互斥锁。通过使用QMutexLocker，我们可以确保在访问共享资源时不会被其他线程打断，从而实现了线程安全的访问。在示例中，我们创建了两个线程，它们都调用了accessResource函数来访问共享资源。由于使用了QMutexLocker，这些访问操作是线程安全的，不会发生冲突或竞态条件。
#include <QCoreApplication>
#include <QReadWriteLock>
#include <QDebug>
#include <QThread>
class SharedResource
{
public:
void readResource() {
QReadLocker locker(&readWriteLock);
// 读取共享资源
qDebug() << "Reading shared resource";
}
void writeResource() {
QWriteLocker locker(&readWriteLock);
// 写入共享资源
qDebug() << "Writing shared resource";
}
private:
QReadWriteLock readWriteLock; // 读写锁
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
SharedResource resource;
// 多个线程同时读取共享资源
QThread thread1, thread2,thread3,thread4,thread5;
QObject::connect(&thread1, &QThread::started, [&](){ resource.readResource(); });
QObject::connect(&thread2, &QThread::started, [&](){ resource.readResource(); });
qDebug() << "================";
// 多个线程同时写入共享资源，并有一个线程同时读取资源
QObject::connect(&thread4, &QThread::started, [&](){ resource.writeResource(); });
QObject::connect(&thread5, &QThread::started, [&](){ resource.readResource(); });
QObject::connect(&thread3, &QThread::started, [&](){ resource.writeResource(); });
thread4.start();
thread5.start();
thread3.start();
thread1.start();
thread2.start();
thread1.wait();
thread2.wait();
thread4.wait();
thread5.wait();
thread3.wait();
return a.exec();
}
定义了一个SharedResource类，它包含两个方法：readResource和writeResource。这两个方法分别用于读取和写入共享资源。为了保护对共享资源的访问，我们在方法内部使用了QReadLocker和QWriteLocker。QReadLocker用于读取时加读锁，允许多个线程同时读取共享资源，但只允许一个线程写入资源。QWriteLocker用于写入时加写锁，只允许一个线程读取或写入资源。通过使用QReadWriteLock，我们可以确保在访问共享资源时不会被其他线程打断，从而实现了线程安全的访问。在示例中，我们创建了三个线程，其中两个线程同时读取共享资源，一个线程同时写入共享资源。由于使用了QReadWriteLock，这些访问操作是线程安全的，不会发生冲突或竞态条件。
#include <QCoreApplication>
#include <QtConcurrent/QFuture>
#include <QDebug>
int compute() {
// 模拟耗时操作
QThread::sleep(2);
return 42;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QFuture<int> future = QtConcurrent::run(compute); // 创建并开始异步任务
int value = future.result(); // 获取异步任务的结果，如果任务未完成则阻塞等待
qDebug() << "Result:" << value;
return a.exec();
}QFuture是一个Qt类，用于表示异步计算的结果。它通常与Qt Concurrent框架一起使用，以便在后台线程中执行任务并获取结果。
QFuture的主要特点是提供了对异步操作结果的访问和监视。通过QFuture，你可以等待计算完成并获取计算结果，而无需阻塞主线程。
QFuture类提供了许多有用的方法来处理异步操作的结果，包括：
QFuture还提供了一个迭代器接口，允许你使用Java风格的迭代器或STL风格的迭代器来遍历结果。这对于处理多个结果的情况非常有用，可以方便地遍历和访问结果数据。
总的来说，QFuture是一个强大的类，提供了对异步操作结果的访问和监视功能。通过使用QFuture，你可以更好地管理异步操作的流程和状态，并避免阻塞主线程，从而提高程序的性能和响应性。
QFutureWatcher是Qt框架中一个非常有用的类，用于监视异步任务的执行状态并获取任务的结果。它提供了一种方便的方式来处理在后台执行的任务，并在任务完成后进行相应的处理。
QFutureWatcher的主要作用是监视一个异步任务的执行状态。它可以告诉我们任务是否已经完成，以及任务的执行进度。当任务完成后，我们可以获取任务的结果并进行相应的处理，例如更新UI界面或执行其他操作。
QFutureWatcher提供了一种事件驱动的方式来监视和处理异步操作的结果。它通过发出信号来通知我们有关异步任务的状态更改和结果就绪的情况。我们可以连接QFutureWatcher的信号到自定义槽函数，以便在适当的时候执行特定的操作。
QFutureWatcher提供了以下重要的信号：
此外，QFutureWatcher还提供了一些有用的槽函数，用于控制异步操作的执行和结果处理，包括：
总的来说，QFutureWatcher是一个功能强大的类，允许我们方便地监视和处理异步任务的结果。通过连接适当的信号和槽函数，我们可以灵活地处理异步操作的状态和结果，从而提高程序的响应性和性能。
#include <QCoreApplication>
#include <QMutex>
#include <QWaitCondition>
#include <QDebug>
#include <QThread>
class MyObject {
public:
MyObject() {
}
void sendData() {
// 锁定互斥量
QMutexLocker locker(&m_mutex);
// 模拟发送数据
qDebug() << "Sending data...";
QThread::sleep(2); // 模拟耗时操作
// 唤醒等待的线程
m_condition.wakeAll();
}
void waitForData() {
// 锁定互斥量
QMutexLocker locker(&m_mutex);
// 等待数据发送完成
while (!m_dataReceived) {
m_condition.wait(&m_mutex);
m_dataReceived = true;
}
// 数据已接收，继续执行其他操作
qDebug() << "Data received!";
}
private:
QMutex m_mutex;
QWaitCondition m_condition;
bool m_dataReceived = false; // 标记数据是否已接收
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
MyObject obj;
// 启动主线程和通信线程
QThread *th1 = QThread::create([&obj]() { obj.waitForData(); });
QThread *th2 = QThread::create([&obj]() { obj.sendData(); });
th1->start();
th2->start();
th1->wait();
th2->wait();
return a.exec();
}
创建了一个MyObject类，它包含一个QWaitCondition对象和一个QMutex对象。sendData()函数模拟了数据发送的过程，并使用QWaitCondition的wakeOne()方法唤醒等待的线程。waitForData()函数则使用QWaitCondition的wait()方法等待数据发送完成。在主函数中，我们创建了两个线程，一个执行waitForData()函数，另一个执行sendData()函数，从而实现多线程的同步。
#include <QCoreApplication>
#include <QSharedMemory>
#include <QDebug>
#include <QSharedMemory>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
// 创建共享内存对象
QSharedMemory sharedMemory("MySharedMemory");
// 尝试获取已存在的共享内存
if (sharedMemory.attach()) {
// 连接到信号槽，用于处理内存映射文件的更改
// 写入数据到共享内存
QByteArray data("Hello, shared memory!");
sharedMemory.lock();
memcpy(sharedMemory.data(), data.data(), data.size());
sharedMemory.unlock();
} else {
// 如果共享内存不存在，则创建新的共享内存并附加到当前进程
if (sharedMemory.create(1024)) {
qDebug() << "Created shared memory segment";
QByteArray data("Hello, shared memory!");
sharedMemory.lock();
memcpy(sharedMemory.data(), data.data(), data.size());
sharedMemory.unlock();
sharedMemory.lock();
QByteArray readData((char*)sharedMemory.constData(), sharedMemory.size());
qDebug() << "读取到的数据:" << readData;
sharedMemory.unlock();
sharedMemory.detach();
} else {
qDebug() << "Failed to create shared memory segment";
}
}
return a.exec();
}
创建了一个QSharedMemory对象，并尝试附加到一个已存在的共享内存段。如果共享内存段不存在，我们创建一个新的共享内存段并将其附加到当前进程。最后，我们启动应用程序并等待用户交互。
hTxEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
ResetEvent(hTxEvent);
SetEvent(hTxEvent);
WaitForSingleObject(hRxEvent,WaitTime);还可以使用Windows 中的上述函数进行线程通信