目录
1、QThread的基本使用
Qt中通过QThread直接支持多线程 ，QThread是一个跨平台的多线程解决方案 ，QThread以简洁易用的方式实现多线程编程
QThread中的关键成员函数
void run() ：线程体函数，用于定义线程功能（执行流）
void start() ：启动函数，将线程入口地址设置为run函数
void terminate() ：强制结束线程（不推荐）， 所有线程都结束后，进程才结束
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QDebug>
class MyThread : public QThread
{
protected:
void run() // 线程入口函数
{
qDebug() << objectName() << " : " << "run() begin";
for(int i=0; i<5; i++)
{
qDebug() << objectName() << " : " << i;
sleep(1);
}
qDebug() << objectName() << " : " << "run() end";
}
};
int main(int argc, char *argv[]) // 主线程入口函数
{
QCoreApplication a(argc, argv);
qDebug() << "main() begin";
MyThread t; // 创建子线程
t.setObjectName("t");
t.start(); // 启动子线程
MyThread tt;
tt.setObjectName("tt");
tt.start();
for(int i=0; i<100000; i++)
{
for(int j=0; j<10000; j++)
{
// 延时， 防止主线程将先于子线程结束
}
}
qDebug() << "main() end";
return a.exec();
}
在默认情况下，各个线程独立存在，并行执行
线程的生命周期
在工程开发中terminate()是禁止使用的，terminate()会使得操作系统暴力终止线程，而不会考虑数据完整性，资源释放等问题！
在代码中优雅的终止线程
－run() 函数执行结束是优雅终止线程的唯一方式
－在线程类中增加标志变量 m_toStop (volatile bool) ，通过m_toStop的值判断是否需要从run()函数返回
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QDebug>
class Sample : public QThread
{
protected:
volatile bool m_toStop;
void run()
{
qDebug() << objectName() << " : begin";
int* p = new int[10000];
for(int i=0; !m_toStop && (i<10); i++)
{
qDebug() << objectName() << " : " << i;
p[i] = i * i * i;
msleep(500);
}
delete[] p;
qDebug() << objectName() << " : end";
}
public:
Sample()
{
m_toStop = false;
}
void stop()
{
m_toStop = true;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug() << "main begin";
Sample t;
t.setObjectName("t");
t.start();
for(int i=0; i<100000; i++)
{
for(int j=0; j<10000; j++)
{
}
}
t.stop(); // 不会资源泄漏
//t.terminate();
qDebug() << "main end";
return a.exec();
}
2、多线程间的同步
并发性是多线程编程的本质 ，在宏观上，所有线程并行执行 ，多个线程间相对独立，互不干涉
在特殊情况下，多线程的执行在时序上存在依赖，所以需要控制多线程间的相对执行顺序。
QThread类直接支持线程间的同步 ，bool QThread::wait(unsigned long time = ULONG_MAX)
求和的新解法、并行计算
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QDebug>
/*
sum(n) => 1 + 2 + 3 + ... + n
sum(1000) => ?
[1, 1000] = [1, 300] [301, 600] [601, 1000]
*/
class Calculator : public QThread
{
protected:
int m_begin;
int m_end;
int m_result;
void run()
{
qDebug() << objectName() << ": run() begin";
for(int i=m_begin; i<=m_end; i++)
{
m_result += i;
msleep(10);
}
qDebug() << objectName() << ": run() end";
}
public:
Calculator(int begin, int end)
{
m_begin = begin;
m_end = end;
m_result = 0;
}
void work()
{
run();
}
int result()
{
return m_result;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug() << "main begin";
Calculator cal1(1, 300);
Calculator cal2(301, 600);
Calculator cal3(601, 1000);
cal1.setObjectName("cal1");
cal2.setObjectName("cal2");
cal3.setObjectName("cal3");
// cal1.work();
// cal2.work();
// cal3.work();
cal1.start();
cal2.start();
cal3.start();
cal1.wait(); // 等待子线程执行结束
cal2.wait();
cal3.wait();
int result = cal1.result() + cal2.result() + cal3.result();
qDebug() << "result = " << result;
qDebug() << "main end";
return a.exec();
}
若没有wait操作，得到的结果是0（三个子线程还没结束就直接获取结果值）
3、多线程间的互斥
3.1、线程锁
临界资源(Critical Resource) ：每次只允许一个线程进行访问（读／写）的资源
线程间的互斥（竞争） ：多个线程在同一时刻都需要访问临界资源
QMutex类是一把线程锁，保证线程间的互斥，利用线程锁能够保证临界资源的安全性
QMutex中的关键成员函数
－void lock()
• 当锁空闲时，获取锁并继续执行
• 当锁被获取，阻塞并等待锁释放
－void unlock()
• 释放锁（同一把锁的获取和释放锁必须在同一线程中成对出现）
• 注意： 如果 mutex 在调用 unlock() 时处于空闲状态，那么程序的行为是未定义的！
生产消费者问题
有n个生产者同时制造产品，并把产品存入仓库中 ；有m个消费者同时需要从仓库中取出产品
规则： 当仓库未满，任意生产者可以存入产品 ；当仓库未空，任意消费者可以取出产品
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QDebug>
static QMutex g_mutex; // 线程锁
static QString g_store; // 仓库
class Producer : public QThread
{
protected:
void run()
{
int count = 0;
while(true)
{
g_mutex.lock();
g_store.append(QString::number((count++) % 10));
qDebug() << objectName() << " : " + g_store;
g_mutex.unlock();
msleep(1);
}
}
};
class Customer : public QThread
{
protected:
void run()
{
while( true )
{
g_mutex.lock();
if( g_store != "" )
{
g_store.remove(0, 1);
qDebug() << objectName() << " : " + g_store;
}
g_mutex.unlock();
msleep(1);
}
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Producer p;
Customer c;
p.setObjectName("Producer");
c.setObjectName("Customer");
p.start();
c.start();
return a.exec();
}
一般性原则 ：每一个临界资源都需要一个线程锁进行保护！
3.2、死锁
死锁示例
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QDebug>
QMutex g_mutex_1;
QMutex g_mutex_2;
class ThreadA : public QThread
{
protected:
void run()
{
while( true )
{
g_mutex_1.lock();
qDebug() << objectName() << "get m1";
g_mutex_2.lock();
qDebug() << objectName() << "get m2";
qDebug() << objectName() << "do work ...";
g_mutex_2.unlock();
g_mutex_1.unlock();
sleep(1);
}
}
};
class ThreadB : public QThread
{
protected:
void run()
{
while( true )
{
g_mutex_2.lock();
qDebug() << objectName() << "get m2";
g_mutex_1.lock();
qDebug() << objectName() << "get m1";
qDebug() << objectName() << "do work ...";
g_mutex_1.unlock();
g_mutex_2.unlock();
sleep(1);
}
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
ThreadA ta;
ThreadB tb;
ta.setObjectName("ta");
tb.setObjectName("tb");
ta.start();
tb.start();
return a.exec();
}
线程的死锁概念 ：线程间相互等待临界资源而造成彼此无法继续执行
发生死锁的条件
－系统中存在多个临界资源且临界资源不可抢占（每次只能给一个线程使用）
－线程需要多个临界资源才能继续执行
－产生死锁有四个必要条件：互斥、请求与保持、不可剥夺、循环等待 （必要条件即满足不一定发生）
死锁的避免 （破坏四个条件）
方法一：资源有序分配法（破坏循环等待）
－对所有的临界资源都分配一个唯一的序号(r1，r2，rn)
－对应的线程锁也分配同样的序号(m1, m2 , mn)
－系统中的每个线程按照严格递增的次序请求资源
3.3、信号量
信号量是特殊的线程锁 ，信号量允许N个线程同时访问临界资源，Qt中直接支持信号量(QSemaphore)
QSemaphore使用示例
QSemaphore对象中维护了一个整型值 ，acquire()使得该值减1 , release()使得该值加1 ，当该值为0时，acquire()函数将阻塞当前线程
再论生产消费者问题 main.cpp
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QSemaphore>
#include <Qdebug>
const int SIZE = 5;
unsigned char g_buff[SIZE] = {0};
QSemaphore g_sem_free(SIZE); // 5个可生产资源
QSemaphore g_sem_used(0); // 0个可消费资源
// 生产者生产产品
class Producer : public QThread
{
protected:
void run()
{
while( true )
{
int value = qrand() % 256;
// 若无法获得可生产资源，阻塞在这里
g_sem_free.acquire();
for(int i=0; i<SIZE; i++)
{
if( !g_buff[i] )
{
g_buff[i] = value;
qDebug() << objectName() << " generate: {" << i << ", " << value << "}";
break;
}
}
// 可消费资源数+1
g_sem_used.release();
sleep(2);
}
}
};
// 消费者消费产品
class Customer : public QThread
{
protected:
void run()
{
while( true )
{
// 若无法获得可消费资源，阻塞在这里
g_sem_used.acquire();
for(int i=0; i<SIZE; i++)
{
if( g_buff[i] )
{
int value = g_buff[i];
g_buff[i] = 0;
qDebug() << objectName() << " consume: {" << i << ", " << value << "}";
break;
}
}
// 可生产资源数+1
g_sem_free.release();
sleep(1);
}
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Producer p1;
Producer p2;
Producer p3;
p1.setObjectName("p1");
p2.setObjectName("p2");
p3.setObjectName("p3");
Customer c1;
Customer c2;
c1.setObjectName("c1");
c2.setObjectName("c2");
p1.start();
p2.start();
p3.start();
c1.start();
c2.start();
return a.exec();
}
3.4、银行家算法的分析与实现
研究一个银行家如何将总数一定的资金，安全地借给若干个顾客，使顾客既能满足对资金的需求，也使银行家可以收回自己的全部资金，不至于破产。
算法策略 ：银行优先分配资源给最小需求的客户
应用场景 ：操作系统内核中的进程管理 ；数据库内核中的频繁事务管理
Qt中的算法实现方案
－使用多线程机制模拟客户和银行
－银行优先分配资源给最小需求的客户
－当客户的资源需求无法满足的时候 ， 收回已分配的资源 ，强制结束线程
银行家算法的实现 main.cpp
#include <QtCore/QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QList>
#include <QDebug>
class Customer : public QThread
{
protected:
int m_need; // 当前顾客所需资金总额
volatile int m_current; // 手中目前已有资金，临界资源
QMutex m_mutex;
void run()
{
bool condition = false;
qDebug() << objectName() << "begin to apply money";
do
{
m_mutex.lock();
condition = (m_current < m_need); // 手中资金比所需资金少，等银行放款
m_mutex.unlock();
msleep(10);
}
while( condition );
qDebug() << objectName() << "end (get enough money)";
}
public:
Customer(int current, int need)
{
m_current = current;
m_need = need;
}
void addMoney(int m)
{
m_mutex.lock();
m_current += m;
m_mutex.unlock();
}
int backMoney()
{
int ret = 0;
m_mutex.lock();
ret = m_current;
m_current = 0;
m_mutex.unlock();
return ret;
}
int current()
{
int ret = 0;
m_mutex.lock();
ret = m_current;
m_mutex.unlock();
return ret;
}
int need()
{
return m_need;
}
};
class Bank : public QThread
{
protected:
QList<Customer*> m_list; // 等待放款的客户
int m_total; // 银行库存资金数
void run()
{
int index = -1;
qDebug() << objectName() << " begin: " << m_total;
do
{
index = -1;
// 若顾客资金已满足需求，收回钱
for(int i=0; i<m_list.count(); i++)
{
if( m_list[i]->current() == m_list[i]->need() )
{
qDebug() << objectName() << " take back money from " << m_list[i]->objectName() << " " << m_list[i]->need();
m_total += m_list[i]->backMoney();
}
}
qDebug() << objectName() << " current: " << m_total;
// 找资金需求量最小客户，得到下标与所需资金
int toGet = 0x00FFFFFF;
for(int i=0; i<m_list.count(); i++)
{
if( m_list[i]->isRunning() )
{
int tmp = m_list[i]->need() - m_list[i]->current();
if( toGet > tmp )
{
index = i;
toGet = tmp;
}
}
}
if( index >=0 )
{
// 资金需求量最小客户所需资金小于银行库存资金，放款
if( toGet <= m_total )
{
qDebug() << objectName() << " give money to: " << m_list[index]->objectName();
m_total--;
m_list[index]->addMoney(1); // 每次放款1单位
}
else
{
qDebug() << objectName() << " terminate: " << m_list[index]->objectName();
m_total += m_list[index]->backMoney(); // 结束贷款，收回钱
m_list[index]->terminate();
}
}
sleep(1);
}
while( index >= 0 );
qDebug() << objectName() << " end: " << m_total;
}
public:
Bank(int total)
{
m_total = total;
}
void addCustomer(Customer* customer)
{
m_list.append(customer);
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Customer p(4, 8);
Customer q(2, 3);
Customer r(2, 11);
Bank bank(2);
p.setObjectName("P");
q.setObjectName("Q");
r.setObjectName("R");
bank.setObjectName("Bank");
bank.addCustomer(&p);
bank.addCustomer(&q);
bank.addCustomer(&r);
p.start();
q.start();
r.start();
bank.start();
return a.exec();
}
4、线程的生命期问题
4.1、线程的生命期问题
C++对象有生命周期； 线程也有生命周期； QThread对象的生命周期与对应的线程生命周期是否一致？
准则 : 线程对象生命期必须大于对应线程生命期 ，遵守这个准则可以避免很多问题
下面代码的问题: 局部对象t在start后就会被销毁，同时成员变量 i 也会被销毁，然而线程还在运行，非法访问已经被销毁的变量
4.2、同步型线程设计
同步型线程设计
－概念 ：线程对象主动等待线程生命期结束后才销毁
－特点 ：同时支持在栈和堆中创建线程对象 ，对象销毁时确保线程生命期结束
－要点 ：在析构函数中先调用wait()函数，强制等到线程运行结束
－使用场合 ：线程生命期相对较短的情形
SyncThread.h
#ifndef SYNCTHREAD_H
#define SYNCTHREAD_H
#include <QThread>
class SyncThread : public QThread
{
Q_OBJECT
protected:
void run();
public:
explicit SyncThread(QObject *parent = 0);
~SyncThread();
};
#endif // SYNCTHREAD_H
SyncThread.cpp
#include "SyncThread.h"
#include <QDebug>
SyncThread::SyncThread(QObject *parent) :
QThread(parent)
{
}
void SyncThread::run()
{
qDebug() << "void SyncThread::run() tid = " << currentThreadId();
for(int i=0; i<3; i++)
{
qDebug() << "void SyncThread::run() i = " << i;
sleep(1);
}
qDebug() << "void SyncThread::run() end";
}
SyncThread::~SyncThread()
{
wait(); // 等待线程结束才析构
qDebug() << "SyncThread::~SyncThread() destroy thread object";
}
main.cpp
#include <QtCore/QCoreApplication>
#include <QDebug>
#include "SyncThread.h"
void sync_thread()
{
SyncThread st;
st.start();
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug() << "main() tid = " << QThread::currentThread();
sync_thread();
return a.exec();
}
4.3、异步型线程设计
异步型线程设计
－概念 ：线程生命期结束时通知销毁线程对象
－特点 ：只能在堆中创建线程对象 ，线程对象不能被外界主动销毁
－要点 ：在 run() 中最后调用 deleteLater() 函数 ，线程体函数主动申请销毁线程对象
－使用场合 ：线程生命期不可控，需要长时间运行于后台的情形
AsyncThread.h
#ifndef ASYNCTHREAD_H
#define ASYNCTHREAD_H
#include <QThread>
class AsyncThread : public QThread
{
Q_OBJECT
protected:
void run();
explicit AsyncThread(QObject *parent = 0); // 只能在堆空间创建对象
~AsyncThread(); // 禁用delete
public:
static AsyncThread* NewInstance(QObject *parent = 0);
};
#endif // ASYNCTHREAD_H
AsyncThread.cpp
#include "AsyncThread.h"
#include <QDebug>
AsyncThread* AsyncThread::NewInstance(QObject *parent)
{
return new AsyncThread(parent);
}
AsyncThread::AsyncThread(QObject *parent) :
QThread(parent)
{
}
void AsyncThread::run()
{
qDebug() << "void AsyncThread::run() tid = " << currentThreadId();
for(int i=0; i<3; i++)
{
qDebug() << "void AsyncThread::run() i = " << i;
sleep(1);
}
qDebug() << "void AsyncThread::run() end";
deleteLater(); // 通知销毁当前线程对象 void QObject::deleteLater () [slot]
}
AsyncThread::~AsyncThread()
{
qDebug() << "AsyncThread::~AsyncThread() destroy thread object";
}
main.cpp
#include <QtCore/QCoreApplication>
#include <QDebug>
#include "AsyncThread.h"
void async_thread()
{
AsyncThread* at = AsyncThread::NewInstance();
at->start();
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug() << "main() tid = " << QThread::currentThread();
async_thread();
return a.exec();
}
5、另一种创建线程的方式（组合）
历史的痕迹
－面向对象程序设计实践的早期，工程中习惯于通过继承的方式扩展系统的功能
－早期的Qt版本只能通过继承的方式创建线桯 ，通过继承的方式实现多线程没有任何实际意义，尽量避免重写void run()
－现代软件技术提倡以组合的方式代替继承
class QThread : public QObject
{
//...
protected:
virtual void run() = 0; // 必须子类实现
//...
} 现代软件架构技术
－参考准则： 尽量使用组合的方式实现系统功能，代码中仅体现需求中的继承关系
除了重写的run不同，其它接口完全相同
QThread类的改进
class QThread : public QObject
{
//...
protected:
virtual void run() // 新版本QT
{
(void)exec(); // 默认开启事件循环
}
//...
} 如何灵活的指定一个线程对象的线程入口函数？
解决方案－信号与槽
1. 在类中定义一个槽函数 void tmain() 作为线程入口函数
2. 在类中定义一个 QThread 成员对象 m_thread
3. 改变当前对象的线程依附性到 m_thread
4 连接 m_thread 的 start() 信号到 tmain()
AnotherThread.h
#ifndef ANOTHERTHREAD_H
#define ANOTHERTHREAD_H
#include <QObject>
#include <QThread>
class AnotherThread : public QObject
{
Q_OBJECT
QThread m_thread;
protected slots:
void tmain(); // 线程入口函数
public:
explicit AnotherThread(QObject *parent = 0);
void start();
void terminate();
void exit(int c);
~AnotherThread();
};
#endif // ANOTHERTHREAD_H
AnotherThread.cpp
#include "AnotherThread.h"
#include <QDebug>
AnotherThread::AnotherThread(QObject *parent) :
QObject(parent)
{
moveToThread(&m_thread);
connect(&m_thread, SIGNAL(started()), this, SLOT(tmain()));
}
void AnotherThread::tmain()
{
qDebug() << "void AnotherThread::tmain() tid = " << QThread::currentThreadId();
for(int i=0; i<10; i++)
{
qDebug() << "void AnotherThread::tmain() i = " << i;
}
qDebug() << "void AnotherThread::tmain() end";
m_thread.quit();
}
void AnotherThread::start()
{
m_thread.start(); // m_thread线程开启，定义的tmain函数被调用(run函数也被调用,开启事件循环)
}
void AnotherThread::terminate()
{
m_thread.terminate();
}
void AnotherThread::exit(int c)
{
m_thread.exit(c);
}
AnotherThread::~AnotherThread()
{
m_thread.wait(); // 同步设计
}
main.cpp
#include <QtCore/QCoreApplication>
#include <QDebug>
#include <QThread>
#include "AnotherThread.h"
void test()
{
AnotherThread at;
at.start();
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug() << "main() tid = " << QThread::currentThreadId();
test();
return a.exec();
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
