服务器之家

服务器之家 > 正文

C++ 简单的任务队列详解

时间:2021-04-22 14:57     来源/作者:C++教程网

任务队列是指能够实现任务在多线程间安全传递的先入先出的队列。

任务是指组合了数据和操作的对象,这里面定义为CTask类的对象。

任务的实现:

Task.cpp

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "stdafx.h"
#include "Task.h"
#include <iostream>
using namespace std;
 
CTask::CTask(int* nCount)
{
  m_nCount = nCount;
}
 
CTask::~CTask()
{
}
 
void CTask::DoWork()
{
  (*m_nCount)++;
 
  cout << "Count = " << *m_nCount << endl;
}

Task.h

?
1
2
3
4
5
6
7
8
9
10
#pragma once
class CTask
{
  int* m_nCount;
public:
  CTask(int* nCount);
  ~CTask();
 
  void DoWork();
};

队列的实现:

TaskQueue.cpp

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include "stdafx.h"
#include "TaskQueue.h"
 
 
CTaskQueue::CTaskQueue()
{
}
 
 
CTaskQueue::~CTaskQueue()
{
}
 
 
//工作线程
void CTaskQueue::WorkThread()
{
  while (m_bIsStart)
  {
    if (!m_taskQueue.empty())
    {
      CTask* it = m_taskQueue.front();
      it->DoWork();
      m_taskQueue.pop();
      delete it;
    }
  }
}
 
//向任务队列添加任务
bool CTaskQueue::Push(CTask* task)
{
  if (task == nullptr)
  {
    return false;
  }
 
  m_mutex.lock();
  m_taskQueue.push(task);
  m_mutex.unlock();
 
  return true;
}
//从任务队列获取任务
CTask* CTaskQueue::Pop()
{
  CTask* it = nullptr;
 
  m_mutex.lock();
  if (!m_taskQueue.empty())
  {
    it = m_taskQueue.front();
    m_taskQueue.pop();
  }
  m_mutex.unlock();
  return it;
}
 
bool CTaskQueue::Start()
{
  if (m_bIsStart)
  {
    return false;
  }
  m_bIsStart = true;
  m_thread = std::thread(&CTaskQueue::WorkThread, this);
 
  return true;
}
 
void CTaskQueue::Stop()
{
  m_bIsStart = false;
  m_thread.join();
}

TaskQueue.h

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#pragma once
#include "Task.h"
#include <queue>
#include <mutex>
#include <thread>
 
class CTaskQueue
{
public:
  CTaskQueue();
  ~CTaskQueue();
 
private:
  std::queue<CTask*> m_taskQueue; //任务队列
  std::thread m_thread;
  std::mutex m_mutex;
  bool m_bIsStart;  //线程是否开启
 
public:
  //工作线程
  void WorkThread();
 
  //向任务队列添加任务
  bool Push(CTask* task);
  //从任务队列获取任务
  CTask* Pop();
 
  //开启线程
  bool Start();
  //终止线程
  void Stop();
};

测试demo:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// TaskQueue.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include "TaskQueue.h"
#include "Task.h"
 
void MyWorkTask1(CTaskQueue* pTaskQueue, int* nCount)
{
  for (size_t i = 0; i < 20; i++)
  
    CTask* task = new CTask(nCount);
    pTaskQueue->Push(task);
  }
}
 
void MyWorkTask2(CTaskQueue* pTaskQueue, int* nCount)
{
  for (size_t i = 0; i < 20; i++)
  {
    CTask* task = new CTask(nCount);
    pTaskQueue->Push(task);
  }
}
 
int _tmain(int argc, _TCHAR* argv[])
{
  CTaskQueue* pTaskQueue = new CTaskQueue();
  pTaskQueue->Start();
 
  int* nCount = new int(0);
 
  std::thread thread1(&MyWorkTask1, pTaskQueue, nCount);
  std::thread thread2(&MyWorkTask2, pTaskQueue, nCount);
 
  //等待线程结束
  if (thread1.joinable())
  {
    thread1.join();
  }
  if (thread2.joinable())
  {
    thread2.join();
  }
 
  system("pause");
  return 0;
}

以上这篇C++ 简单的任务队列详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。

标签:

相关文章

热门资讯

2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
Intellij idea2020永久破解,亲测可用!!!
Intellij idea2020永久破解,亲测可用!!! 2020-07-29
返回顶部