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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
/*
* This file is part of nzbget. See <http://nzbget.net>.
*
* Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
* Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "nzbget.h"
#include "Log.h"
#include "Thread.h"
int Thread::m_threadCount = 1; // take the main program thread into account
std::unique_ptr<Mutex> Thread::m_threadMutex;
Mutex::Mutex()
{
#ifdef WIN32
InitializeCriticalSection(&m_mutexObj);
#else
pthread_mutex_init(&m_mutexObj, nullptr);
#endif
}
Mutex::~Mutex()
{
#ifdef WIN32
DeleteCriticalSection(&m_mutexObj);
#else
pthread_mutex_destroy(&m_mutexObj);
#endif
}
void Mutex::Lock()
{
#ifdef WIN32
EnterCriticalSection(&m_mutexObj);
#ifdef DEBUG
// CriticalSections on Windows can be locked many times from the same thread,
// but we do not want this and must treat such situations as errors and detect them.
if (m_mutexObj.RecursionCount > 1)
{
error("Internal program error: inconsistent thread-lock detected");
}
#endif
#else
pthread_mutex_lock(&m_mutexObj);
#endif
}
void Mutex::Unlock()
{
#ifdef WIN32
LeaveCriticalSection(&m_mutexObj);
#else
pthread_mutex_unlock(&m_mutexObj);
#endif
}
void Thread::Init()
{
debug("Initializing global thread data");
m_threadMutex = std::make_unique<Mutex>();
}
Thread::Thread()
{
debug("Creating Thread");
}
Thread::~Thread()
{
debug("Destroying Thread");
}
void Thread::Start()
{
debug("Starting Thread");
m_running = true;
// NOTE: we must guarantee, that in a time we set m_running
// to value returned from pthread_create, the thread-object still exists.
// This is not obvious!
// pthread_create could wait long enough before returning result
// back to allow the started thread to complete its job and terminate.
// We lock mutex m_threadMutex on calling pthread_create; the started thread
// then also try to lock the mutex (see thread_handler) and therefore
// must wait until we unlock it
Guard guard(m_threadMutex);
#ifdef WIN32
m_threadObj = (HANDLE)_beginthread(Thread::thread_handler, 0, (void*)this);
m_running = m_threadObj != 0;
#else
pthread_attr_t m_attr;
pthread_attr_init(&m_attr);
pthread_attr_setdetachstate(&m_attr, PTHREAD_CREATE_DETACHED);
pthread_attr_setinheritsched(&m_attr, PTHREAD_INHERIT_SCHED);
m_running = !pthread_create(&m_threadObj, &m_attr, Thread::thread_handler, (void *) this);
pthread_attr_destroy(&m_attr);
#endif
}
void Thread::Stop()
{
debug("Stopping Thread");
m_stopped = true;
}
void Thread::Resume()
{
debug("Resuming Thread");
m_stopped = false;
}
bool Thread::Kill()
{
debug("Killing Thread");
Guard guard(m_threadMutex);
#ifdef WIN32
bool terminated = TerminateThread(m_threadObj, 0) != 0;
#else
bool terminated = pthread_cancel(m_threadObj) == 0;
#endif
if (terminated)
{
m_threadCount--;
}
return terminated;
}
#ifdef WIN32
void __cdecl Thread::thread_handler(void* object)
#else
void* Thread::thread_handler(void* object)
#endif
{
{
Guard guard(m_threadMutex);
m_threadCount++;
}
debug("Entering Thread-func");
Thread* thread = (Thread*)object;
thread->Run();
debug("Thread-func exited");
thread->m_running = false;
if (thread->m_autoDestroy)
{
debug("Autodestroying Thread-object");
delete thread;
}
{
Guard guard(m_threadMutex);
m_threadCount--;
}
#ifndef WIN32
return nullptr;
#endif
}
int Thread::GetThreadCount()
{
Guard guard(m_threadMutex);
return m_threadCount;
}
|
