263 lines
6.5 KiB
C++
263 lines
6.5 KiB
C++
/*
|
|
PIP - Platform Independent Primitives
|
|
Thread
|
|
Copyright (C) 2013 Ivan Pelipenko peri4ko@gmail.com
|
|
|
|
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 3 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 "pithread.h"
|
|
#include "pisystemtests.h"
|
|
|
|
|
|
void piUSleep(int usecs) {
|
|
#ifdef WINDOWS
|
|
if (usecs > 0) Sleep(usecs / 1000);
|
|
#else
|
|
usecs -= PISystemTests::usleep_offset_us;
|
|
if (usecs > 0) usleep(usecs);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*! \class PIThread
|
|
* \brief Thread class
|
|
* \details This class allow you exec your code in separate thread.
|
|
*
|
|
* \section PIThread_sec0 Synopsis
|
|
* Multithread .
|
|
*
|
|
* \section PIThread_sec1 To/from data convertions
|
|
* Most common constructor is \a PIThread(const char * str), where "str"
|
|
* is null-terminated string, e.g. \c "string". This is 7 chars with last char = 0.
|
|
* Also you can constructs \a PIThread from single \a PIChar, \a PIByteArray,
|
|
* other \a PIThread or sequency of the same characters with custom length.\n \n
|
|
* This class has implicit conversions to <tt>const char * </tt> and
|
|
* \c std::string. Also there are functions to make same convertions:
|
|
* * \a data() - to <tt>const char * </tt>,
|
|
* * \a stdString() - to \c std::string,
|
|
* * \a toByteArray() - to \a PIByteArray.
|
|
*
|
|
* \section PIThread_sec2 Numeric operations
|
|
* You can get symbolic representation of any numeric value with function
|
|
* \a setNumber(any integer value, int base = 10, bool * ok = 0). Default
|
|
* arguments are set for decimal base system, but you can choose any system
|
|
* from 2 to 40. There are the same static functions \a fromNumber(), that
|
|
* returns \a PIThread. \n
|
|
* Also there is function \a setReadableSize() which is set human-readable
|
|
* size in bytes, Kb, Mb, Gb or Pb. Static analog is \a readableSize().
|
|
*
|
|
*/
|
|
|
|
|
|
PIThread::PIThread(void * data, ThreadFunc func, bool startNow, int timer_delay): PIObject() {
|
|
piMonitor.threads++;
|
|
thread = 0;
|
|
data_ = data;
|
|
ret_func = func;
|
|
running = lockRun = false;
|
|
priority_ = piNormal;
|
|
timer = timer_delay;
|
|
if (startNow) start(timer_delay);
|
|
}
|
|
|
|
|
|
PIThread::PIThread(bool startNow, int timer_delay): PIObject() {
|
|
piMonitor.threads++;
|
|
thread = 0;
|
|
ret_func = 0;
|
|
running = lockRun = false;
|
|
priority_ = piNormal;
|
|
timer = timer_delay;
|
|
if (startNow) start(timer_delay);
|
|
}
|
|
|
|
|
|
PIThread::~PIThread() {
|
|
piMonitor.threads--;
|
|
if (!running || thread == 0) return;
|
|
#ifndef WINDOWS
|
|
pthread_cancel(thread);
|
|
#else
|
|
TerminateThread(thread, 0);
|
|
CloseHandle(thread);
|
|
#endif
|
|
}
|
|
|
|
|
|
bool PIThread::start(int timer_delay) {
|
|
if (running) return false;
|
|
terminating = running = false;
|
|
timer = timer_delay;
|
|
#ifndef WINDOWS
|
|
pthread_attr_t attr;
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setschedparam(&attr, &sparam);
|
|
if (pthread_create(&thread, &attr, thread_function, this) == 0) {
|
|
setPriority(priority_);
|
|
running = true;
|
|
return true;
|
|
}
|
|
#else
|
|
thread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_function, this, 0, 0);
|
|
if (thread != 0) {
|
|
setPriority(priority_);
|
|
running = true;
|
|
return true;
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PIThread::startOnce() {
|
|
if (running) return false;
|
|
terminating = running = false;
|
|
#ifndef WINDOWS
|
|
pthread_attr_t attr;
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setschedparam(&attr, &sparam);
|
|
if (pthread_create(&thread, &attr, thread_function_once, this) == 0) {
|
|
setPriority(priority_);
|
|
running = true;
|
|
return true;
|
|
}
|
|
#else
|
|
thread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_function_once, this, 0, 0);
|
|
if (thread != 0) {
|
|
setPriority(priority_);
|
|
running = true;
|
|
return false;
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
|
|
void PIThread::terminate() {
|
|
if (thread == 0) return;
|
|
running = false;
|
|
#ifndef WINDOWS
|
|
pthread_cancel(thread);
|
|
#else
|
|
TerminateThread(thread, 0);
|
|
CloseHandle(thread);
|
|
#endif
|
|
thread = 0;
|
|
end();
|
|
}
|
|
|
|
|
|
void * PIThread::thread_function(void * t) {
|
|
#ifndef WINDOWS
|
|
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
|
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
|
|
#endif
|
|
PIThread & ct = *((PIThread * )t);
|
|
ct.running = true;
|
|
ct.begin();
|
|
ct.started();
|
|
while (!ct.terminating) {
|
|
if (ct.lockRun) ct.mutex_.lock();
|
|
ct.run();
|
|
if (ct.ret_func != 0) ct.ret_func(ct.data_);
|
|
if (ct.lockRun) ct.mutex_.unlock();
|
|
if (ct.timer > 0) msleep(ct.timer);
|
|
}
|
|
ct.stopped();
|
|
ct.end();
|
|
ct.running = false;
|
|
//cout << "thread " << t << " exiting ... " << endl;
|
|
#ifndef WINDOWS
|
|
pthread_exit(0);
|
|
#else
|
|
ExitThread(0);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
void * PIThread::thread_function_once(void * t) {
|
|
#ifndef WINDOWS
|
|
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
|
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
|
|
#endif
|
|
PIThread & ct = *((PIThread * )t);
|
|
ct.running = true;
|
|
ct.begin();
|
|
ct.started();
|
|
if (ct.lockRun) ct.mutex_.lock();
|
|
ct.run();
|
|
if (ct.ret_func != 0) ct.ret_func(ct.data_);
|
|
if (ct.lockRun) ct.mutex_.unlock();
|
|
ct.stopped();
|
|
ct.end();
|
|
ct.running = false;
|
|
//cout << "thread " << t << " exiting ... " << endl;
|
|
#ifndef WINDOWS
|
|
pthread_exit(0);
|
|
#else
|
|
ExitThread(0);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
void PIThread::setPriority(PIThread::Priority prior) {
|
|
priority_ = prior;
|
|
#ifndef WINDOWS
|
|
# ifndef LINUX
|
|
sparam.sched_priority = (int)priority_;
|
|
# else
|
|
sparam.__sched_priority = (int)priority_;
|
|
# endif
|
|
if (!running) return;
|
|
pthread_getschedparam(thread, &policy, &sparam);
|
|
pthread_setschedparam(thread, policy, &sparam);
|
|
#else
|
|
if (!running) return;
|
|
SetThreadPriority(thread, -(int)priority_);
|
|
#endif
|
|
}
|
|
|
|
|
|
bool PIThread::waitForFinish(int timeout_msecs) {
|
|
if (timeout_msecs < 0) {
|
|
while (running)
|
|
msleep(1);
|
|
return true;
|
|
}
|
|
int cnt = 0;
|
|
while (running && cnt < timeout_msecs) {
|
|
msleep(1);
|
|
++cnt;
|
|
}
|
|
return cnt < timeout_msecs;
|
|
}
|
|
|
|
|
|
bool PIThread::waitForStart(int timeout_msecs) {
|
|
if (timeout_msecs < 0) {
|
|
while (!running)
|
|
msleep(1);
|
|
return true;
|
|
}
|
|
int cnt = 0;
|
|
while (!running && cnt < timeout_msecs) {
|
|
msleep(1);
|
|
++cnt;
|
|
}
|
|
return cnt < timeout_msecs;
|
|
}
|