Skip to content

Commit aedb770

Browse files
sea5kgsea5kg
committed
Renamed
1 parent 180bad7 commit aedb770

5 files changed

Lines changed: 92 additions & 87 deletions

File tree

‎.gitignore‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
wsjcpp-async-jobs-pool
22
tmp/*
3+
.wsjcpp/*
34

45
# Prerequisites
56
*.d

‎src/wsjcpp_async_jobs_pool.cpp‎

Lines changed: 52 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -3,21 +3,21 @@
33

44
// ---------------------------------------------------------------------
55

6-
JobAsync::JobAsync(const std::string &sName) {
6+
WSJCppAsyncJob::WSJCppAsyncJob(const std::string &sName) {
77
m_sName = sName;
88
}
99

1010
// ---------------------------------------------------------------------
1111

12-
const std::string &JobAsync::name() {
12+
const std::string &WSJCppAsyncJob::name() {
1313
return m_sName;
1414
}
1515

1616
// ---------------------------------------------------------------------
1717

18-
JobAsync *JobAsyncDeque::pop() {
18+
WSJCppAsyncJob *WSJCppAsyncJobDeque::pop() {
1919
std::lock_guard<std::mutex> guard(this->m_mtxJobsAsyncDeque);
20-
JobAsync *pJobAsync = nullptr;
20+
WSJCppAsyncJob *pJobAsync = nullptr;
2121
int nSize = m_dequeJobsAsync.size();
2222
if (nSize > 0) {
2323
pJobAsync = m_dequeJobsAsync.back();
@@ -28,7 +28,7 @@ JobAsync *JobAsyncDeque::pop() {
2828

2929
// ----------------------------------------------------------------------
3030

31-
void JobAsyncDeque::push(JobAsync *pJobAsync) {
31+
void WSJCppAsyncJobDeque::push(WSJCppAsyncJob *pJobAsync) {
3232
std::lock_guard<std::mutex> guard(this->m_mtxJobsAsyncDeque);
3333
if (m_dequeJobsAsync.size() > 20) {
3434
WSJCppLog::warn(TAG, " deque more than " + std::to_string(m_dequeJobsAsync.size()));
@@ -38,7 +38,7 @@ void JobAsyncDeque::push(JobAsync *pJobAsync) {
3838

3939
// ----------------------------------------------------------------------
4040

41-
void JobAsyncDeque::cleanup() {
41+
void WSJCppAsyncJobDeque::cleanup() {
4242
std::lock_guard<std::mutex> guard(this->m_mtxJobsAsyncDeque);
4343
while (m_dequeJobsAsync.size() > 0) {
4444
delete m_dequeJobsAsync.back();
@@ -48,7 +48,7 @@ void JobAsyncDeque::cleanup() {
4848

4949
// ----------------------------------------------------------------------
5050

51-
bool JobAsyncDeque::isEmpty() {
51+
bool WSJCppAsyncJobDeque::isEmpty() {
5252
std::lock_guard<std::mutex> guard(this->m_mtxJobsAsyncDeque);
5353
bool bRet = m_dequeJobsAsync.size() == 0;
5454
return bRet;
@@ -57,16 +57,16 @@ bool JobAsyncDeque::isEmpty() {
5757
// ----------------------------------------------------------------------
5858

5959
void* processJobsThreadWorker(void *arg) {
60-
JobsThreadWorker *pWorker = (JobsThreadWorker *)arg;
60+
WSJCppAsyncJobsThreadWorker *pWorker = (WSJCppAsyncJobsThreadWorker *)arg;
6161
pthread_detach(pthread_self());
6262
pWorker->run();
6363
return 0;
6464
}
6565

6666
// ----------------------------------------------------------------------
6767

68-
JobsThreadWorker::JobsThreadWorker(const std::string &sName, JobAsyncDeque *pDeque) {
69-
TAG = "JobsThreadWorker-" + sName;
68+
WSJCppAsyncJobsThreadWorker::WSJCppAsyncJobsThreadWorker(const std::string &sName, WSJCppAsyncJobDeque *pDeque) {
69+
TAG = "WSJCppAsyncJobsThreadWorker-" + sName;
7070
m_pDeque = pDeque;
7171
m_bStop = false;
7272
m_bBuzy = false;
@@ -75,32 +75,32 @@ JobsThreadWorker::JobsThreadWorker(const std::string &sName, JobAsyncDeque *pDeq
7575

7676
// ----------------------------------------------------------------------
7777

78-
void JobsThreadWorker::start() {
78+
void WSJCppAsyncJobsThreadWorker::start() {
7979
m_bStop = false;
8080
pthread_create(&m_threadWorker, NULL, &processJobsThreadWorker, (void *)this);
8181
}
8282

8383
// ----------------------------------------------------------------------
8484

85-
void JobsThreadWorker::stop() {
85+
void WSJCppAsyncJobsThreadWorker::stop() {
8686
m_bStop = true;
8787
}
8888

8989
// ----------------------------------------------------------------------
9090

91-
bool JobsThreadWorker::isBuzy() {
91+
bool WSJCppAsyncJobsThreadWorker::isBuzy() {
9292
return m_bBuzy;
9393
}
9494

9595
// ----------------------------------------------------------------------
9696

97-
void JobsThreadWorker::run() {
97+
void WSJCppAsyncJobsThreadWorker::run() {
9898
while (1) {
9999
if (m_bStop) {
100100
m_bBuzy = false;
101101
return;
102102
}
103-
JobAsync *pJobAsync = m_pDeque->pop();
103+
WSJCppAsyncJob *pJobAsync = m_pDeque->pop();
104104
while (pJobAsync != nullptr) {
105105
m_bBuzy = true;
106106
pJobAsync->run(TAG);
@@ -122,93 +122,93 @@ void JobsThreadWorker::run() {
122122

123123
// ----------------------------------------------------------------------
124124

125-
JobAsyncDeque *g_pJobsFastPool = nullptr;
126-
std::vector<JobsThreadWorker *> *g_vJobsFastWorkers = nullptr;
127-
int g_nMaxJobFastWorker = 2;
125+
WSJCppAsyncJobDeque *g_pWSJCppAsyncJobsFastPool = nullptr;
126+
std::vector<WSJCppAsyncJobsThreadWorker *> *g_vWSJCppAsyncJobsFastWorkers = nullptr;
127+
int g_nMaxWSJCppAsyncJobFastWorker = 2;
128128

129-
void JobsPool::initGlobalVariables() {
130-
if (g_pJobsFastPool == nullptr) {
131-
g_pJobsFastPool = new JobAsyncDeque();
129+
void WSJCppAsyncJobsPool::initGlobalVariables() {
130+
if (g_pWSJCppAsyncJobsFastPool == nullptr) {
131+
g_pWSJCppAsyncJobsFastPool = new WSJCppAsyncJobDeque();
132132
}
133-
if (g_vJobsFastWorkers == nullptr) {
134-
g_vJobsFastWorkers = new std::vector<JobsThreadWorker *>();
133+
if (g_vWSJCppAsyncJobsFastWorkers == nullptr) {
134+
g_vWSJCppAsyncJobsFastWorkers = new std::vector<WSJCppAsyncJobsThreadWorker *>();
135135
// 2 threads default
136-
for (int i = 0; i < g_nMaxJobFastWorker; i++) {
137-
g_vJobsFastWorkers->push_back(new JobsThreadWorker("fast-worker" + std::to_string(i), g_pJobsFastPool));
136+
for (int i = 0; i < g_nMaxWSJCppAsyncJobFastWorker; i++) {
137+
g_vWSJCppAsyncJobsFastWorkers->push_back(new WSJCppAsyncJobsThreadWorker("fast-worker" + std::to_string(i), g_pWSJCppAsyncJobsFastPool));
138138
}
139139
}
140140
}
141141

142142
// ----------------------------------------------------------------------
143143

144144
// Two queue for fast jobs
145-
void JobsPool::addJobFast(JobAsync *pJobAsync) {
146-
JobsPool::initGlobalVariables();
147-
g_pJobsFastPool->push(pJobAsync);
145+
void WSJCppAsyncJobsPool::addJobFast(WSJCppAsyncJob *pJobAsync) {
146+
WSJCppAsyncJobsPool::initGlobalVariables();
147+
g_pWSJCppAsyncJobsFastPool->push(pJobAsync);
148148
}
149149

150150
// ----------------------------------------------------------------------
151151

152152
// Long time jobs like a send a lot of emails and etc...
153153
// better keep this list of jobs to storage
154-
void JobsPool::addJobSlow(JobAsync *pJobAsync) {
155-
JobsPool::initGlobalVariables();
156-
WSJCppLog::warn("JobsPool", "addJobSlow not implemented yet");
154+
void WSJCppAsyncJobsPool::addJobSlow(WSJCppAsyncJob *pJobAsync) {
155+
WSJCppAsyncJobsPool::initGlobalVariables();
156+
WSJCppLog::warn("WSJCppAsyncJobsPool", "addJobSlow not implemented yet");
157157
// g_pJobsLong->push(pJobAsync);
158158
}
159159

160160
// ----------------------------------------------------------------------
161161

162162
// jobs with delay
163-
void JobsPool::addJobDelay(int nMilliseconds, JobAsync *pJobAsync) {
164-
JobsPool::initGlobalVariables();
165-
WSJCppLog::warn("JobsPool", "addJobDelay not implemented yet");
163+
void WSJCppAsyncJobsPool::addJobDelay(int nMilliseconds, WSJCppAsyncJob *pJobAsync) {
164+
WSJCppAsyncJobsPool::initGlobalVariables();
165+
WSJCppLog::warn("WSJCppAsyncJobsPool", "addJobDelay not implemented yet");
166166
// g_pJobsShort->push(pJobAsync);
167167
}
168168

169169
// ----------------------------------------------------------------------
170170

171171
// jobs by cron, for example every 5 minutes execute some job
172-
void JobsPool::addJobCron(JobSchedule *pJobSchedule, JobAsync *pJobAsync) {
173-
JobsPool::initGlobalVariables();
174-
WSJCppLog::warn("JobsPool", "addJobCron not implemented yet");
172+
void WSJCppAsyncJobsPool::addJobShedule(WSJCppAsyncJobSchedule *pJobSchedule, WSJCppAsyncJob *pJobAsync) {
173+
WSJCppAsyncJobsPool::initGlobalVariables();
174+
WSJCppLog::warn("WSJCppAsyncJobsPool", "addJobShedule not implemented yet");
175175
// g_pJobsShort->push(pJobAsync);
176176
}
177177

178178
// ----------------------------------------------------------------------
179179

180-
void JobsPool::stop() {
181-
JobsPool::initGlobalVariables();
182-
for (int i = 0; i < g_vJobsFastWorkers->size(); i++) {
183-
g_vJobsFastWorkers->at(i)->stop();
180+
void WSJCppAsyncJobsPool::stop() {
181+
WSJCppAsyncJobsPool::initGlobalVariables();
182+
for (int i = 0; i < g_vWSJCppAsyncJobsFastWorkers->size(); i++) {
183+
g_vWSJCppAsyncJobsFastWorkers->at(i)->stop();
184184
}
185185
}
186186

187187
// ----------------------------------------------------------------------
188188

189-
void JobsPool::start() {
190-
JobsPool::initGlobalVariables();
191-
for (int i = 0; i < g_vJobsFastWorkers->size(); i++) {
192-
g_vJobsFastWorkers->at(i)->start();
189+
void WSJCppAsyncJobsPool::start() {
190+
WSJCppAsyncJobsPool::initGlobalVariables();
191+
for (int i = 0; i < g_vWSJCppAsyncJobsFastWorkers->size(); i++) {
192+
g_vWSJCppAsyncJobsFastWorkers->at(i)->start();
193193
}
194194
// TODO slow
195195
// TODO thread for cron and delay
196196
}
197197

198198
// ----------------------------------------------------------------------
199199

200-
void JobsPool::waitForDone() {
200+
void WSJCppAsyncJobsPool::waitForDone() {
201201
// TODO when job in progress need wait deque for progress jobs ?
202-
JobsPool::initGlobalVariables();
202+
WSJCppAsyncJobsPool::initGlobalVariables();
203203
bool bBuzy = true;
204204
while (bBuzy) {
205205
bBuzy = false;
206206
std::this_thread::sleep_for(std::chrono::milliseconds(100));
207-
if (!g_pJobsFastPool->isEmpty()) {
207+
if (!g_pWSJCppAsyncJobsFastPool->isEmpty()) {
208208
bBuzy = true;
209209
}
210-
for (int i = 0; i < g_vJobsFastWorkers->size(); i++) {
211-
if (g_vJobsFastWorkers->at(i)->isBuzy()) {
210+
for (int i = 0; i < g_vWSJCppAsyncJobsFastWorkers->size(); i++) {
211+
if (g_vWSJCppAsyncJobsFastWorkers->at(i)->isBuzy()) {
212212
bBuzy = true;
213213
}
214214
}
@@ -217,8 +217,8 @@ void JobsPool::waitForDone() {
217217

218218
// ----------------------------------------------------------------------
219219

220-
void JobsPool::cleanup() {
221-
g_pJobsFastPool->cleanup();
220+
void WSJCppAsyncJobsPool::cleanup() {
221+
g_pWSJCppAsyncJobsFastPool->cleanup();
222222
// TODO slow
223223
// TODO thread for cron and delay
224224
}

‎src/wsjcpp_async_jobs_pool.h‎

Lines changed: 27 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
1-
#ifndef JOBS_POOL_H
2-
#define JOBS_POOL_H
1+
#ifndef WSJCPP_ASYNC_JOBS_POOL_H
2+
#define WSJCPP_ASYNC_JOBS_POOL_H
33

44
#include <string>
55
#include <mutex>
66
#include <deque>
77
#include <thread>
88
#include <vector>
99

10-
class JobAsync {
10+
class WSJCppAsyncJob {
1111
public:
12-
JobAsync(const std::string &sName);
12+
WSJCppAsyncJob(const std::string &sName);
1313
const std::string &name();
1414
virtual bool run(const std::string &sWorkerId) = 0;
1515

@@ -19,33 +19,33 @@ class JobAsync {
1919

2020
// ---------------------------------------------------------------------
2121

22-
class JobSchedule {
22+
class WSJCppAsyncJobSchedule {
2323
public:
2424
// TODO
2525
};
2626

2727
// ---------------------------------------------------------------------
2828

29-
class JobAsyncDeque {
29+
class WSJCppAsyncJobDeque {
3030
public:
31-
JobAsync *pop();
32-
void push(JobAsync *pJobAsync);
31+
WSJCppAsyncJob *pop();
32+
void push(WSJCppAsyncJob *pJobAsync);
3333
void cleanup();
3434
bool isEmpty();
3535

3636
private:
3737
std::string TAG;
3838

3939
std::mutex m_mtxJobsAsyncDeque;
40-
std::deque<JobAsync *> m_dequeJobsAsync;
40+
std::deque<WSJCppAsyncJob *> m_dequeJobsAsync;
4141
};
4242

4343
// ---------------------------------------------------------------------
4444

45-
class JobsThreadWorker {
45+
class WSJCppAsyncJobsThreadWorker {
4646
public:
4747

48-
JobsThreadWorker(const std::string &sName, JobAsyncDeque *pDeque);
48+
WSJCppAsyncJobsThreadWorker(const std::string &sName, WSJCppAsyncJobDeque *pDeque);
4949

5050
void start();
5151
void stop();
@@ -54,34 +54,37 @@ class JobsThreadWorker {
5454
private:
5555
std::string TAG;
5656
std::string m_sName;
57-
JobAsyncDeque *m_pDeque;
57+
WSJCppAsyncJobDeque *m_pDeque;
5858
bool m_bBuzy;
5959
bool m_bStop;
6060
pthread_t m_threadWorker;
6161
};
6262

6363
// ---------------------------------------------------------------------
6464

65-
extern JobAsyncDeque *g_pJobsFastPool;
66-
extern std::vector<JobsThreadWorker *> *g_vJobsFastWorkers;
67-
extern int g_nMaxJobFastWorker;
65+
extern WSJCppAsyncJobDeque *g_pWSJCppAsyncJobsFastPool;
66+
extern std::vector<WSJCppAsyncJobsThreadWorker *> *g_vWSJCppAsyncJobsFastWorkers;
67+
extern int g_nMaxWSJCppAsyncJobFastWorker;
6868

69-
extern JobAsyncDeque *g_pJobsLongPool; // TODO
70-
extern JobAsyncDeque *g_pJobsDelay; // TODO
71-
extern JobAsyncDeque *g_pJobsCron; // TODO
69+
extern WSJCppAsyncJobDeque *g_pWSJCppAsyncJobsLongPool; // TODO
70+
extern WSJCppAsyncJobDeque *g_pWSJCppAsyncJobsDelay; // TODO
71+
extern WSJCppAsyncJobDeque *g_pWSJCppAsyncJobsCron; // TODO
7272
// TODO control thread will be add delay and cron jobs to long
7373

7474
// TODO statistics
7575
// TODO max thread different workers
7676

77-
class JobsPool {
77+
class WSJCppAsyncJobsPool {
7878
public:
7979
static void initGlobalVariables();
8080

81-
static void addJobSlow(JobAsync *pJobAsync);
82-
static void addJobFast(JobAsync *pJobAsync);
83-
static void addJobDelay(int nMilliseconds, JobAsync *pJobAsync);
84-
static void addJobCron(JobSchedule *pJobSchedule,JobAsync *pJobAsync);
81+
static void addJobSlow(WSJCppAsyncJob *pJobAsync);
82+
static void addJobFast(WSJCppAsyncJob *pJobAsync);
83+
static void addJobDelay(int nMilliseconds, WSJCppAsyncJob *pJobAsync);
84+
static void addJobShedule(
85+
WSJCppAsyncJobSchedule *pJobSchedule,
86+
WSJCppAsyncJob *pJobAsync
87+
);
8588

8689
static void stop();
8790
static void start();
@@ -91,4 +94,4 @@ class JobsPool {
9194

9295
// ---------------------------------------------------------------------
9396

94-
#endif // JOBS_POOL_H
97+
#endif // WSJCPP_ASYNC_JOBS_POOL_H

0 commit comments

Comments
 (0)