首页 > 编程语言 > 详细

lesson15-QT多线程

时间：2016-02-27 02:20:05      阅读：326      评论：0      收藏：0      [点我收藏+]
一、什么是线程
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、多线程

点击(此处)折叠或打开

  1. #ifndef MYTHREAD_H
  2. #define MYTHREAD_H

  4. #include <QThread>

  6. class MyThread : public QThread
  7. {
  8. Q_OBJECT
  9. public:
  10.     MyThread();
  11.     void stop();
  12.     volatile bool stopped;
  13. protected:
  14.     void run();
  15. };
  16. #endif

点击(此处)折叠或打开

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

  4. MyThread::MyThread()
  5. {
  6.     stopped = false;
  7. }

  9. void MyThread::run()
  10. {
  11.     int i=0;
  12.     while(!stopped)
  13.     {
  14.         qDebug()<<"thread id:"<QThread::currentThreadId()<<":"<<i;
  15.         i++;
  16.         sleep(2);
  17.     }
  18.     stopped = false;
  19. }

  21. void MyThread::stop()
  22. {
  23.     stopped = true;
  24. }

2、信号量

点击(此处)折叠或打开

  1. #ifndef PRODUCER_H
  2. #define PRODUCER_H

  4. #include <QThread>

  6. class Producer : public QThread
  7. {
  8. Q_OBJECT
  9. public:
  10.     Producer();
  11. protected:
  12.     void run();
  13. };

  15. #endif

点击(此处)折叠或打开

  1. #ifndef CONSUMER_H
  2. #define CONSUMER_H

  4. #include <QThread>

  6. class Consumer : public QThread
  7. {
  8. Q_OBJECT
  9. public:
  10.     Consumer();
  11. protected:
  12.     void run();
  13. };

  15. #endif

点击(此处)折叠或打开

  1. #include "producer.h"
  2. #include "consumer.h"
  3. #include <QDebug>
  4. #include <QSemaphore>

  6. #define SIZE 50
  7. QSemaphore freeByte(SIZE);
  8. QSemaphore useByte(0);

  10. Producer::Producer()
  11. {

  13. }
  14. void Producer::run()
  15. {
  16.     for(int i=0; i<SIZE; i++)
  17.     {
  18.         freeByte.acquire();
  19.         qDebug()<<"produer:"<<i;
  20.         useByte.release();
  21.         sleep(1);
  22.     }
  23. }
  24. Consumer::Consumer()
  25. {

  27. }
  28. void Consumer::run()
  29. {
  30.     for(int i=0; i<SIZE; i++)
  31.     {
  32.         useByte.acquire();
  33.         qDebug()<<"consumer:"<<i;
  34.         freeByte.release();
  35.         sleep(2);
  36.     }
  37. }


3、条件变量

点击(此处)折叠或打开

  1. #ifndef THREAD_H
  2. #define THREAD_H

  4. #include<QThread>

  6. class Producer : public QThread
  7. {
  8. Q_OBJECT
  9. public:
  10.     Producer();
  11. protected:
  12.     void run();
  13. };

  15. class Consumer : public QThread
  16. {
  17. Q_OBJECT
  18. public:
  19.     Consumer();
  20. protected:
  21.     void run();
  22. };

  24. #endif

点击(此处)折叠或打开

  1. #include "thread.h"
  2. #include <QDebug>
  3. #include <QMutex>
  4. #include <QWaitCondition>

  6. QMutex mutex;
  7. QWaitCondition empty, full;
  8. int num=0;
  9. int buffer[50];
  10. int useByte=0;


  13. Producer::Producer()
  14. {

  16. }
  17. void Producer::run()
  18. {
  19.     for(int i=0; i<50; i++)
  20.     {
  21.         mutex.lock();
  22.         if(useByte==50)
  23.             empty.wait(&mutex);
  24.         num++;
  25.         buffer[i] = num;
  26.         qDebug()<<"producer:"<<num;
  27.         useByte++;
  28.         full.wakeAll();
  29.         mutex.unlock();
  30.         sleep(1);
  31.     }
  32. }
  33. Consumer::Consumer()
  34. {

  36. }
  37. void Consumer::run()
  38. {
  39.     for(int i=0; i<50; i++)
  40.     {
  41.         mutex.lock();
  42.         if(useByte==0)
  43.             full.wait(&mutex);
  44.         qDebug()<<"consumer"<<buffer[i];
  45.         useByte--;
  46.         empty.wakeAll();
  47.         mutex.unlock();
  48.         sleep(2);
  49.     }
  50. }



lesson15-QT多线程

原文：http://blog.chinaunix.net/uid-29270124-id-5611667.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！