QT 多线程 互斥

qt应用的多线程实例简单实现，语法超级简单，用两种方法实现同步和互斥。一种是Semaphore信号量，另一种是mutex锁和condition条件变量。下面开始。

第一种，QSemaphore信号量方式：

通过Qt Creator创建一个控制台项目，项目创建完以后只有一个main.cpp文件和一个.pro配置文件，在main.cpp添加如下内容

1. #include <QSemaphore>

2. #include <QThread>

3. #include <QApplication>

5. const qint32 DataSize=10;

6. const qint32 BufferSize=4;

8. //仓库

9. int buffer[BufferSize];

10. //控制生产者线程信号量：写入的数据缓冲区

11. QSemaphore freeSpace(BufferSize);

12. //控制消费者线程信号量：读取的数据缓冲区

13. QSemaphore usedSpace(0);

15. //生产者线程类

16. class threadProducer:public QThread

17. {

18. public:

19. void run()

20. {

21. for(int i=0;i<DataSize;++i)

22. {

23. //仓库有空闲位置，生产一个数据

24. //空闲位置少一个，控制生产的信号量加一

25. freeSpace.acquire();

26. buffer[i%4]=i+1;

27. qDebug("producer::%d",buffer[i%4]);

28. //可消费的数据多一个，控制消费者信号量+1

29. usedSpace.release();

30. sleep(1);

31. }

32. }

33. };

34. class threadConsumer:public QThread

35. {

36. public:

37. void run()

38. {

39. for(int i=0;i<DataSize;++i)

40. {

41. usedSpace.acquire();

42. qDebug("consumer:%d",buffer[i%4]);

43. freeSpace.release();

44. sleep(2);

45. }

46. }

47. };

49. int main(int argc, char *argv[])

50. {

51. QCoreApplication a(argc, argv);

52. threadConsumer consumer;

53. threadProducer producer;

54. producer.start();

55. consumer.start();

56. producer.wait();

57. consumer.wait();

58. return a.exec();

59. }

第二种，QWaitCondition和QMutex方式

1. #include <QCoreApplication>

2. #include <QThread>

3. #include <QWaitCondition>

4. #include <QMutex>

6. const qint32 DataSize=10;

7. const qint32 BufferSize=4;

10. int buffer[BufferSize];

11. QWaitCondition bufferIsNotFull;

12. QWaitCondition bufferIsNotEmpty;

13. QMutex mutex;

14. int usedSpace=0;

16. //生产者线程类

17. class threadProducer:public QThread

18. {

19. public:

20. void run()

21. {

22. for (int i=0; i<DataSize; ++i)

23. {

24. mutex.lock();

25. //如果仓库满了，不生产，等待销费

26. while (usedSpace==BufferSize)

27. {

28. bufferIsNotFull.wait(&mutex);

29. }

30. buffer[i%4]=i+1;

31. qDebug("producer:%d",buffer[i%4]);

32. ++usedSpace;

33. bufferIsNotEmpty.wakeAll();

34. mutex.unlock();

35. }

36. }

37. };

39. class threadConsumer:public QThread

40. {

41. public:

42. void run()

43. {

44. for(int i=0;i<DataSize;++i)

45. {

46. mutex.lock();

47. while (usedSpace==0)

48. {

49. bufferIsNotEmpty.wait(&mutex);

50. }

51. qDebug("consumer:%d",buffer[i%4]);

52. --usedSpace;

53. bufferIsNotFull.wakeAll();

54. mutex.unlock();

55. }

56. }

57. };

59. int main(int argc, char *argv[])

60. {

61. QCoreApplication a(argc, argv);

62. threadConsumer consumer;

63. threadProducer producer;

64. producer.start();

65. consumer.start();

66. producer.wait();

67. consumer.wait();

68. return a.exec();

69. }