【C++】 Qt-线程并发与线程同步

**Qt线程并发与线程同步**

在Qt中，线程并发是指多个线程同时执行不同的任务，而线程同步则是指确保多个线程之间的操作顺序一致。线程并发和线程同步是 Qt 中一个非常重要的概念，它们可以帮助我们提高程序的性能和可靠性。

**1. 线程并发**

在Qt中，线程并发可以通过使用 `QThread` 类来实现。下面是一个简单的例子：

cpp#include 
#include 

class MyThread : public QThread {
public:
 void run() override {
 // 执行任务 qDebug() << "线程执行了";
 }
};

int main() {
 MyThread thread;
 thread.start();
 return0;
}

在这个例子中，我们创建了一个 `MyThread` 类，继承自 `QThread`。在 `run()` 函数中，我们执行了一个任务，即打印 "线程执行了" 的日志信息。

然后，在 `main()` 函数中，我们创建了一个 `MyThread` 对象，并调用其 `start()` 函数来启动线程。

**2. 线程同步**

在Qt中，线程同步可以通过使用 `QMutex` 类来实现。下面是一个简单的例子：

cpp#include 
#include 

class MyThread : public QThread {
public:
 void run() override {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 执行任务 qDebug() << "线程执行了";
 //释放锁 mutex.unlock();
 }
};

int main() {
 MyThread thread;
 thread.start();
 return0;
}

在这个例子中，我们创建了一个 `MyThread` 类，继承自 `QThread`。在 `run()` 函数中，我们获取了一个锁（使用 `lock()` 函数），执行了一个任务，即打印 "线程执行了" 的日志信息，然后释放了锁（使用 `unlock()` 函数）。

**3. 线程安全的数据结构**

在Qt中，线程安全的数据结构可以通过使用 `QMutex` 类来实现。下面是一个简单的例子：

cpp#include 
#include 

class MyData {
public:
 int value;

 void setValue(int val) {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 设置值 value = val;
 //释放锁 mutex.unlock();
 }

 int getValue() {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 返回值 return value;
 //释放锁 mutex.unlock();
 }
};

int main() {
 MyData data;
 data.setValue(10);
 qDebug() << data.getValue(); // 输出:10 return0;
}

在这个例子中，我们创建了一个 `MyData` 类，包含一个 `value` 成员变量。我们定义了两个函数：`setValue()` 和 `getValue()`。在这两个函数中，我们使用 `QMutex` 来获取锁，然后设置或返回值。

**4. 线程安全的信号和槽**

在Qt中，线程安全的信号和槽可以通过使用 `QObject::connect()` 函数来实现。下面是一个简单的例子：

cpp#include 
#include 

class MyObject : public QObject {
public:
 Q_OBJECTsignals:
 void mySignal();

public slots:
 void slot() {
 // 发送信号 emit mySignal();
 }
};

int main() {
 MyObject obj;
 QObject::connect(&obj, &MyObject::mySignal, [](){
 qDebug() << "收到信号";
 });
 return0;
}

在这个例子中，我们创建了一个 `MyObject` 类，继承自 `QObject`。我们定义了一个信号 `mySignal()` 和一个槽函数 `slot()`。在 `slot()` 函数中，我们发送了一个信号 `mySignal()`。

然后，在 `main()` 函数中，我们连接了信号和槽函数。每当信号 `mySignal()` 发送时，槽函数就会被调用。

**5. 线程安全的共享资源**

在Qt中，线程安全的共享资源可以通过使用 `QSharedData` 类来实现。下面是一个简单的例子：

cpp#include 
#include 

class MyResource {
public:
 int value;

 void setValue(int val) {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 设置值 value = val;
 //释放锁 mutex.unlock();
 }

 int getValue() {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 返回值 return value;
 //释放锁 mutex.unlock();
 }
};

int main() {
 MyResource resource;
 resource.setValue(10);
 qDebug() << resource.getValue(); // 输出:10 return0;
}

在这个例子中，我们创建了一个 `MyResource` 类，包含一个 `value` 成员变量。我们定义了两个函数：`setValue()` 和 `getValue()`。在这两个函数中，我们使用 `QMutex` 来获取锁，然后设置或返回值。

**6. 线程安全的队列**

在Qt中，线程安全的队列可以通过使用 `QQueue` 类来实现。下面是一个简单的例子：

cpp#include <QQueue>
#include <QDebug>

class MyQueue {
public:
 QQueue<int> queue;

 void enqueue(int val) {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 添加元素 queue.enqueue(val);
 //释放锁 mutex.unlock();
 }

 int dequeue() {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 移除元素 if (!queue.isEmpty()) {
 return queue.dequeue();
 } else {
 return -1; // 队列为空 }
 //释放锁 mutex.unlock();
 }
};

int main() {
 MyQueue queue;
 queue.enqueue(10);
 qDebug() << queue.dequeue(); // 输出:10 return0;
}

在这个例子中，我们创建了一个 `MyQueue` 类，包含一个 `queue` 成员变量。我们定义了两个函数：`enqueue()` 和 `dequeue()`。在这两个函数中，我们使用 `QMutex` 来获取锁，然后添加或移除元素。

**7. 线程安全的堆栈**

在Qt中，线程安全的堆栈可以通过使用 `QStack` 类来实现。下面是一个简单的例子：

cpp#include <QStack>
#include <QDebug>

class MyStack {
public:
 QStack<int> stack;

 void push(int val) {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 添加元素 stack.push(val);
 //释放锁 mutex.unlock();
 }

 int pop() {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 移除元素 if (!stack.isEmpty()) {
 return stack.pop();
 } else {
 return -1; // 堆栈为空 }
 //释放锁 mutex.unlock();
 }

 int peek() {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 返回顶部元素 if (!stack.isEmpty()) {
 return stack.top();
 } else {
 return -1; // 堆栈为空 }
 //释放锁 mutex.unlock();
 }
};

int main() {
 MyStack stack;
 stack.push(10);
 qDebug() << stack.pop(); // 输出:10 return0;
}

在这个例子中，我们创建了一个 `MyStack` 类，包含一个 `stack` 成员变量。我们定义了三个函数：`push()`、`pop()` 和 `peek()`。在这三个函数中，我们使用 `QMutex` 来获取锁，然后添加或移除元素。

**8. 线程安全的链表**

在Qt中，线程安全的链表可以通过使用 `QList` 类来实现。下面是一个简单的例子：

cpp#include <QList>
#include <QDebug>

class MyList {
public:
 QList<int> list;

 void append(int val) {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 添加元素 list.append(val);
 //释放锁 mutex.unlock();
 }

 int remove(int index) {
 // 获取锁 QMutex mutex;
 mutex.lock();
 // 移除元素 if (index >=0 && index < list.size()) {
 return list.removeAt(index);
 } else {
 return -1; // 索引越界 }
 //