lesson15-QT多線程

lesson15-QT多線程

一、什麼是線程
1、線程
進程：一個正在執行的程序，它是資源分配的最小單位
線程：程序執行的最小單位

進程出現了很多弊端，一是由於進程是資源擁有者，創建、撤消與切換存在較大的時空開銷，因此需要引入輕型進程；二是由於對稱多處理機（SMP）出現，可以滿足多個運行單位，而多個進程並行開銷過大。

2、線程的術語
並發是指在同一時刻，只能有一條指令執行，但多個進程指令被快速輪換執行，使得在宏觀上具有多個進程同時執行的效果。
看起來同時發生

並行是指在同一時刻，有多條指令在多個處理器上同時執行。
真正的同時發生

同步：彼此有依賴關系的調用不應該“同時發生”，而同步就是要阻止那些“同時發生”的事情
異步的概念和同步相對，任何兩個彼此獨立的操作是異步的，它表明事情獨立的發生

3、線程的優勢
1）、在多處理器中開發程序的並行性
2）、在等待慢速IO操作時，程序可以執行其他操作，提高並發性
3）、模塊化的編程，能更清晰的表達程序中獨立事件的關系，結構清晰
4）、占用較少的系統資源

多線程不一定要多處理器
GUI程序中經常會使用多線程技術，一個線程用來響應界面，而其他線程就可以在後台處理冗長的操作
Qt的元對象系統支持不同線程中的對象使用信號和槽機制通信




二、QT多線程
Qt中使用多線程是非常簡單的，只要子類話QThread就可以了，在QThread中有一個protected類型的run函數，重寫run函數就可以實現多線程。
1、QT線程
Qt中使用多線程是非常簡單的，只要子類化QThread，然後重寫run函數就可以實現多線程

class MyThread:public Thread
{
public:
MyThread();
protected:
void run();
private:
volatile boolean stopped;
}

run函數是通過線程的start方法啟動的，線程還有isRunning方法來判斷是否在運行，terminate方法結束線程


2、線程同步之信號量
信號量使線程不需要忙碌的等待，是對mutex的一種擴展。使用信號量可以保證兩個關鍵代碼不會並發。在進入一段關鍵代碼時，線程必須獲取信號量，退出時必須釋放。信號量可以同時由多個線程訪問。

Qt的信號量QSemaphore類：
acquire()用來獲取資源，free()用來釋放資源

生產者和消費者的例子，生產者生產的時候需要確保有足夠的空間，消費者消費的時候要確保空間裡有資源
QSemaphore freeByte(100) 生產有有100個空間
QSemaphore useByte(0)消費者沒有資源
producer
{
freeByte.acquire()
byte = n
useByte.release()
}
consumer
{
useByte.acquire()
printf byte
freeByte.release()
}


3、線程同步之條件變量
QWaitCondition允許線程在一定條件下喚醒其他的線程，這樣也可以是線程不必忙碌的等待，條件變量要配合互斥量來使用

QMutex mutex； QWaitCondition condition；
condition.wait(&mutex)
condition.wakeAll()
wait函數將互斥量解鎖，並在此等待，此函數返回之前會將互斥量重新枷鎖。
wakeAll函數會將所有等待該互斥量的線程喚醒


4、線程優先級
實際任務可能會讓某個線程先運行，那麼就需要設置線程優先級。
setPriority函數可以設置線程的優先級，或者在線程啟動的時候在start函數傳入線程的優先級


三、實例
1、多線程

#ifndef MYTHREAD_H
 
#define MYTHREAD_H

#include <QThread>

class MyThread : public QThread
{
Q_OBJECT
public:
MyThread();
void stop();
volatile bool stopped;
protected:
void run();
};
#endif

#include "myThread.h"
 
#include <QtDebug>

MyThread::MyThread()
{
stopped = false;
}

void MyThread::run()
{
int i=0;
while(!stopped)
{
qDebug()<<"thread id:"<QThread::currentThreadId()<<":"<<i;
i++;
sleep(2);
}
stopped = false;
}

void MyThread::stop()
{
stopped = true;
} 

2、信號量

#ifndef PRODUCER_H
 
#define PRODUCER_H

#include <QThread>

class Producer : public QThread
{
Q_OBJECT
public:
Producer();
protected:
void run();
};

#endif

#ifndef CONSUMER_H
 
#define CONSUMER_H

#include <QThread>

class Consumer : public QThread
{
Q_OBJECT
public:
Consumer();
protected:
void run();
};

#endif

#include "producer.h"
 
#include "consumer.h"
#include <QDebug>
#include <QSemaphore>

#define SIZE 50
QSemaphore freeByte(SIZE);
QSemaphore useByte(0);

Producer::Producer()
{

}
void Producer::run()
{
for(int i=0; i<SIZE; i++)
{
freeByte.acquire();
qDebug()<<"produer:"<<i;
useByte.release();
sleep(1);
}
}
Consumer::Consumer()
{

}
void Consumer::run()
{
for(int i=0; i<SIZE; i++)
{
useByte.acquire();
qDebug()<<"consumer:"<<i;
freeByte.release();
sleep(2);
}
} 

3、條件變量

#ifndef THREAD_H
 
#define THREAD_H

#include<QThread>

class Producer : public QThread
{
Q_OBJECT
public:
Producer();
protected:
void run();
};

class Consumer : public QThread
{
Q_OBJECT
public:
Consumer();
protected:
void run();
};

#endif

#include "thread.h"
 
#include <QDebug>
#include <QMutex>
#include <QWaitCondition>

QMutex mutex;
QWaitCondition empty, full;
int num=0;
int buffer[50];
int useByte=0;


Producer::Producer()
{

}
void Producer::run()
{
for(int i=0; i<50; i++)
{
mutex.lock();
if(useByte==50)
empty.wait(&mutex);
num++;
buffer[i] = num;
qDebug()<<"producer:"<<num;
useByte++;
full.wakeAll();
mutex.unlock();
sleep(1);
}
}
Consumer::Consumer()
{

}
void Consumer::run()
{
for(int i=0; i<50; i++)
{
mutex.lock();
if(useByte==0)
full.wait(&mutex);
qDebug()<<"consumer"<<buffer[i];
useByte--;
empty.wakeAll();
mutex.unlock();
sleep(2);
}
}