一、什么是线程
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、多线程
2、信号量
3、条件变量
1、线程
进程：一个正在执行的程序，它是资源分配的最小单位
线程：程序执行的最小单位
进程出现了很多弊端，一是由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入轻型进程；二是由于对称多处理机（SMP）出现，可以满足多个运行单位，而多个进程并行开销过大。
2、线程的术语
并发是指在同一时刻，只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。
看起来同时发生
并行是指在同一时刻，有多条指令在多个处理器上同时执行。
真正的同时发生
同步：彼此有依赖关系的调用不应该“同时发生”，而同步就是要阻止那些“同时发生”的事情
异步的概念和同步相对，任何两个彼此独立的操作是异步的，它表明事情独立的发生
3、线程的优势
1）、在多处理器中开发程序的并行性
2）、在等待慢速IO操作时，程序可以执行其他操作，提高并发性
3）、模块化的编程，能更清晰的表达程序中独立事件的关系，结构清晰
4）、占用较少的系统资源
多线程不一定要多处理器
GUI程序中经常会使用多线程技术，一个线程用来响应界面，而其他线程就可以在后台处理冗长的操作
Qt的元对象系统支持不同线程中的对象使用信号和槽机制通信
Qt中使用多线程是非常简单的，只要子类话QThread就可以了，在QThread中有一个protected类型的run函数，重写run函数就可以实现多线程。
Qt中使用多线程是非常简单的，只要子类化QThread，然后重写run函数就可以实现多线程
class MyThread:public Thread
{
public:
MyThread();
protected:
void run();
private:
volatile boolean stopped;
}
run函数是通过线程的start方法启动的，线程还有isRunning方法来判断是否在运行，terminate方法结束线程
信号量使线程不需要忙碌的等待，是对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
#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;
}
#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
#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
#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; iSIZE; i++)
{
freeByte.acquire();
qDebug()"produer:"i;
useByte.release();
sleep(1);
}
}
Consumer::Consumer()
{
}
void Consumer::run()
{
for(int i=0; iSIZE; i++)
{
useByte.acquire();
qDebug()"consumer:"i;
freeByte.release();
sleep(2);
}
}
#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; iSIZE; i++)
{
freeByte.acquire();
qDebug()"produer:"i;
useByte.release();
sleep(1);
}
}
Consumer::Consumer()
{
}
void Consumer::run()
{
for(int i=0; iSIZE; i++)
{
useByte.acquire();
qDebug()"consumer:"i;
freeByte.release();
sleep(2);
}
}
3、条件变量
点击(此处)折叠或打开
#ifndef THREAD_H
#define THREAD_H
#includeQThread>
class Producer : public QThread
{
Q_OBJECT
public:
Producer();
protected:
void run();
};
class Consumer : public QThread
{
Q_OBJECT
public:
Consumer();
protected:
void run();
};
#endif
#define THREAD_H
#includeQThread>
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; i50; 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; i50; i++)
{
mutex.lock();
if(useByte==0)
full.wait(&mutex);
qDebug()"consumer"buffer[i];
useByte--;
empty.wakeAll();
mutex.unlock();
sleep(2);
}
}
#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; i50; 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; i50; i++)
{
mutex.lock();
if(useByte==0)
full.wait(&mutex);
qDebug()"consumer"buffer[i];
useByte--;
empty.wakeAll();
mutex.unlock();
sleep(2);
}
}
