Потоки. Малая разница в производительности

@NEvOl · Регистрация: 13.08.2012

Студворк — интернет-сервис помощи студентам

Здравствуйте, продолжаю дальше разбираться с потоками. Имеется класс потока:

C++
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
#include "xyzQsort.h"
#include <mutex>
#include <thread>
#define TH_COMPLITE 1
#define TH_NO_COMPLITE -1
#define TH_VOID 0
 
struct task
{
    XMFLOAT4  *pArray;
    int type;
    int num;
};
 
class  MyThread
{
private:
 
    std::mutex *mtx;
    std::vector<task> *tasks;
    bool *terminate;
    int id;
    void workThread();
public:
    std::thread thr;
    int status;
    MyThread(int id, std::mutex *mtx, std::vector<task> *tasks, bool *terminate);
    ~MyThread();
};
 
MyThread::MyThread(int id, std::mutex *mtx, std::vector<task> *tasks, bool *terminate)
{
    this->id = id;
    this->mtx = mtx;
    this->status = TH_VOID;
    this->tasks = tasks;
    this->terminate = terminate;
    this->thr = std::thread(&MyThread::workThread, this);
}
 
MyThread::~MyThread()
{
 
}
 
void MyThread::workThread()
{
    task t;
    t.type = 0;
    while (1)
    {
        this->mtx->lock();
        if (!this->tasks->empty())
        {
            t = (*this->tasks)[this->tasks->size() - 1];
            this->tasks->pop_back();
            this->status = TH_NO_COMPLITE;
        }
        else
            this->status = TH_COMPLITE;
        this->mtx->unlock();
        if (t.type != 0)
        {
            switch (t.type)
            {
            case -1:
                qSortX(t.pArray, t.num);
                break;
            case -2:
                qSortY(t.pArray, t.num);
                break;
            case -3:
                qSortZ(t.pArray, t.num);
                break;
            }
            t.type = 0;
            this->status = TH_COMPLITE;
            continue;
        }
        else
        {
            if (*(this->terminate))
                return;
        }
            
    }
}
//содержимое файла #include "xyzQsort.h"
int funcX(const void* a, const void* b)
{
    if ((*(XMFLOAT4*)a).x > (*(XMFLOAT4*)b).x)
        return 1;
    if ((*(XMFLOAT4*)a).x < (*(XMFLOAT4*)b).x)
        return -1;
    return 0;
}
 
int funcY(const void* a, const void* b)
{
    if ((*(XMFLOAT4*)a).y >(*(XMFLOAT4*)b).y)
        return 1;
    if ((*(XMFLOAT4*)a).y < (*(XMFLOAT4*)b).y)
        return -1;
    return 0;
}
 
int funcZ(const void* a, const void* b)
{
    if ((*(XMFLOAT4*)a).z >(*(XMFLOAT4*)b).z)
        return 1;
    if ((*(XMFLOAT4*)a).z < (*(XMFLOAT4*)b).z)
        return -1;
    return 0;
}
 
void qSortZ(XMFLOAT4 *p, int num)
{
    std::qsort(p, num, sizeof(XMFLOAT4), funcZ);
}
 
void qSortY(XMFLOAT4 *p, int num)
{
    std::qsort(p, num, sizeof(XMFLOAT4), funcY);
}
 
void qSortX(XMFLOAT4 *p, int num)
{
    std::qsort(p, num, sizeof(XMFLOAT4), funcX);
}

Есть другой класс который эти потоки порождает и взаимодействует с ними:

C++
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
class kdTree
{
private:
    std::vector<MyThread*> thrs;
    std::vector<task> tasks;
    bool terminate;
    std::mutex mtx;
    void CreateTree(XMFLOAT4 *p, std::vector<node> &nd, int num);
    void CreateThread(int numTh);
    void AddTask(XMFLOAT4 *pArray, int num, int type);
    void WaitToComplete();
    void Join();
public:
    kdTree(XMFLOAT4 *p, int n);
    ~kdTree();
};
 
 
void kdTree::CreateTree(XMFLOAT4 *p, std::vector<node> &nd, int num)
{
    int lIndex(-1);
 
#ifdef vec
    std::vector<XMFLOAT4> x, y, z;
#endif
 
#ifndef vec
    XMFLOAT4 *x, *y, *z;
#endif
    for (int i = 0; i < 1000; i++)
    {
#ifdef vec
        x.resize(num);
        y.resize(num);
        z.resize(num);
 
        std::memcpy(&x[0], p + begin, sizeof(XMFLOAT4)*num);
 
        y = z = x;
#endif
 
#ifndef vec
        x = new XMFLOAT4[num];
        y = new XMFLOAT4[num];
        z = new XMFLOAT4[num];
 
        std::memcpy(x, p + begin, sizeof(XMFLOAT4)*num);
        std::memcpy(y, p + begin, sizeof(XMFLOAT4)*num);
        std::memcpy(z, p + begin, sizeof(XMFLOAT4)*num);
#endif
        
#ifdef thQsort
        this->AddTask(&x[0], num, -1);
        this->AddTask(&y[0], num, -2);
        this->AddTask(&z[0], num, -3);
        this->WaitToComplete();
#endif
 
#ifdef Qsort
        qSortX(&x[0], num);
        qSortY(&y[0], num);
        qSortZ(&z[0], num);
#endif
 
        switch (++lIndex % 3)
        {
        case 0:
            memcpy(p + begin, &x[0], sizeof(XMFLOAT4)*num);
            break;
        case 1:
            memcpy(p + begin, &y[0], sizeof(XMFLOAT4)*num);
            break;
        case 2:
            memcpy(p + begin, &z[0], sizeof(XMFLOAT4)*num);
            break;
        }
        
#ifdef vec
        x.clear();
        y.clear();
        z.clear();
#endif
 
#ifndef vec
        delete[]x;
        delete[]y;
        delete[]z;
#endif
    }
    this->Join();
    return;
}
 
kdTree::kdTree(XMFLOAT4 *p, int n)
{
#ifdef thQsort
    this->CreateThread(numThrs);
#endif
    this->CreateTree(p, newP, n);
 
}
 
void kdTree::CreateThread(int numTh)
{
    this->terminate = 0;
    for (int i = 0; i < numTh; i++)
        this->thrs.push_back(new MyThread(i, &this->mtx, &this->tasks, &this->terminate));      
}
 
 
void kdTree::AddTask(XMFLOAT4 *pArray, int num, int type)
{
    task t;
    t.pArray = pArray;
    t.num = num;
    t.type = type;
    mtx.lock();
    this->tasks.push_back(t);
    mtx.unlock();
}
 
void kdTree::Join()
{
    this->terminate = 1;
    for (int i = 0; i < this->thrs.size(); i++)
        (*this->thrs[i]).thr.join();
}
 
void kdTree::WaitToComplete()
{
    int work = 1;
    while (work)
    {
        work = 0;
        for (int i = 0; i < this->thrs.size(); i++)
            if ((*this->thrs[i]).status != TH_COMPLITE)
                work = 1;
    }
}

Суть этих классов в том что мы создаем нужное нам число потоков, которые крутятся в бесконечных циклах (workThread) и опрашивают очередь заданий на сортировку массивов, если задания есть то поток вытаскивает данные и сортирует их, при этом мы вызываем функцию WaitToComplete, которая "останавливает" работу основного потока пока не выполнятся все задачи, как поток выполнил задачу он опять начинается бесконечно крутиться и ждать, для того что бы прибить все потоки используется функнция Join. Тестирую программу (CreateTree), при работе с обычными указателями разница в производительности очень мала (#define thQsort, секунд 10) по сравнению с работой без потоков (при размере входного массива в 10000 элементов), если работаю с векторами (#define vec) то разницы вообще никакой нет, создаю я 3 потока (#define numThrs 3), подскажите пожалуйста что не так у меня ?

@NEvOl · 04.11.2014, 12:17 **[ТС]**

Avazart, как вы и посоветовали изменил подход, несомненно появился прирост в скорости, сейчас уже 45-50 с против 115-116 с, но проблема с засыпанием главного потока не исчезла, можете подсказать что не так ?
рабочая функция:

C++
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
void MyThread::workThread()
{
    while (1)
    {
        bool isEmpty = 0;
        while ((isEmpty = (this->num == 0)) && !(*this->terminate))
        {
            this->status = TH_COMPLITE;
            std::unique_lock<std::mutex> locker(*this->mtx);
            (*this->manager).wait(locker);
        }
 
        if (!isEmpty)
        {
            switch (this->type)
            {
            case -1:
                qSortX(this->pArray, this->num);
                break;
            case -2:
                qSortY(this->pArray, this->num);
                break;
            case -3:
                qSortZ(this->pArray, this->num);
                break;
            }
            this->num = 0;
            this->status = TH_COMPLITE;//после выполнения задания
            (*this->isComplite).notify_all();//будим главный поток
            continue;
        }
        else
            if (*(this->terminate))
                return;
    }
}

функция ожидания:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void kdTree::WaitToComplete()
{
    int work = numThrs;
    
    while (work)
    {
        std::unique_lock<std::mutex> locker(mtxCmp);
        isComplite.wait(locker);//тогда засыпаем
 
        work = 0;
        for (int i = 0; i < this->thrs.size(); i++)
            if ((*this->thrs[i]).status != TH_COMPLITE)//если не все потоки выполнили задания
                work = 1;
        
    }
}

добавление задачи стал теперь метод класса потока:

C++
1
2
3
4
5
6
void MyThread::AddTask(XMFLOAT4 *pArray, int num, int type)
{
    this->pArray = pArray;
    this->num = num;
    this->type = type;
}

изменился соответственно конструктор:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
MyThread::MyThread(int id, std::mutex *mtx, bool *terminate, std::condition_variable *manager, std::condition_variable *isComplite, std::mutex *mtxCmp)
{
    this->id = id;
    this->mtx = mtx;
    this->mtxCmp = mtxCmp;
    this->status = TH_COMPLITE;
    this->terminate = terminate;
    this->manager = manager;
    this->isComplite = isComplite;
    this->type = 0;
    this->pArray = NULL;
    this->num = 0;
    this->thr = std::thread(&MyThread::workThread, this);
}

изменение и чтение состояния тоже нужно блокировать ?

@DrOffset · 04.11.2014, 17:27

Сообщение от NEvOl

но проблема с засыпанием главного потока не исчезла

Я не очень понимаю логику твоей функции ожидания.
В последнем моем примере логика ожидания такая:
Статусов нет. Есть количество потоков занятых работой. Как только работа одного из них завершается, он сбрасывает переменную состояния. Цикл ожидания уменьшает счетчик занятых потоков и снова становится на ожидание. Если счетчик занятых потоков равен нулю, то выходим из цикла.

Сообщение от NEvOl

изменение и чтение состояния тоже нужно блокировать ?

Да. Это же тоже разделяемый ресурс.
Или можно использовать std::atomic.

@NEvOl · 04.11.2014, 17:40 **[ТС]**

DrOffset, я изучал ваш код, а если поток завершит работу до того как функция ожидания будет вызвана ?

@DrOffset · 04.11.2014, 18:26

NEvOl, Да, это недочет. В таком случае при завершении работы тоже нужно сбрасывать переменную состояния.

Добавлено через 12 минут
NEvOl, можно переделать следующим образом:

Кликните здесь для просмотра всего текста

C++
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
class Status
{
public:
    Status()
        : threads_()
    { }
 
    void addThread()
    {
        ++threads_;
    }
 
    void wait()
    {
        int count = threads_;
        std::unique_lock<std::mutex> locker(waitMutex_);
        while(count > 0)
        {
            waitCond_.wait(locker);
            --count;
        }
    }
 
    void wakeUp()
    {
        std::lock_guard<std::mutex> lock(waitMutex_);
        waitCond_.notify_one();
    }
 
private:
    std::mutex waitMutex_;
    std::condition_variable waitCond_;
    int threads_;
};
 
class Thread
{
public:
    Thread(Status & status)
        : status_(status), terminate_(false), thr_(&Thread::run, this)
    {
        status_.addThread();
    }
 
    void join()
    {
        {
            std::lock_guard<std::mutex> lock(taskMutex_);
            terminate_ = true;
            taskSync_.notify_one();
        }
        thr_.join();
    }
 
    void addTask(int task)
    {
        std::lock_guard<std::mutex> lock(taskMutex_);
        tasks_.push(task);
        taskSync_.notify_one();
    }
 
private:
    void run()
    {
        bool proceed = true;
        while(proceed)
        {
            int  task;
            bool hasTask;
            bool needWakeUp;
            {
                std::unique_lock<std::mutex> locker(taskMutex_);
                while(!terminate_ && tasks_.empty())
                {
                    taskSync_.wait(locker);
                }
                hasTask = !tasks_.empty();
                proceed = !terminate_;
                needWakeUp = terminate || hasTask; 
 
                if(hasTask)
                {
                    task = tasks_.front();
                    tasks_.pop();
                }
            }
            if(hasTask)
            {
                // здесь выполняем задание из очереди (без блокировки)
            }
            if(needWakeUp)
            {
                status_.wakeUp(); // будим основной поток если нужно завершиться или выполнили задание
            }
        }
    }
 
private:
    Status & status_;
 
    bool terminate_;
    std::queue<int> tasks_;
 
    std::condition_variable taskSync_;
    std::mutex taskMutex_;
    std::thread thr_;
};
...........

Добавлено через 3 минуты

Сообщение от NEvOl

а если поток завершит работу до того как функция ожидания будет вызвана ?

Черт, я сперва подумал о другом

(если поток завершился, но не сказал основному проснуться). Да, это решение не пойдет. Сейчас переделаю.

Добавлено через 15 минут
Как-то так:

Кликните здесь для просмотра всего текста

C++
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
class Status
{
public:
    Status()
        : tasks_()
    { }
 
    void addTaskToWait()
    {
        std::lock_guard<std::mutex> lock(waitMutex_);
        ++tasks_;
    }
 
    void wait()
    {
        std::unique_lock<std::mutex> locker(waitMutex_);
        while(tasks_ > 0)
        {
            waitCond_.wait(locker);
        }
    }
 
    void wakeUp(int tasks = 1)
    {
        std::lock_guard<std::mutex> lock(waitMutex_);
        tasks_ -= tasks;
        waitCond_.notify_one();
    }
 
private:
    std::mutex waitMutex_;
    std::condition_variable waitCond_;
    int tasks_;
};
 
class Thread
{
public:
    Thread(Status & status)
        : status_(status), terminate_(false), thr_(&Thread::run, this)
    { }
 
    void join()
    {
        {
            std::lock_guard<std::mutex> lock(taskMutex_);
            terminate_ = true;
            taskSync_.notify_one();
        }
        thr_.join();
    }
 
    void addTask(int task)
    {
        status_.addTaskToWait();  // увеличиваем счетчик заданий
        std::lock_guard<std::mutex> lock(taskMutex_);
        tasks_.push(task);
        taskSync_.notify_one();
    }
 
private:
    void run()
    {
        bool proceed = true;
        while(proceed)
        {
            int  task;
            bool hasTask;
            bool needWakeUp;
            {
                std::unique_lock<std::mutex> locker(taskMutex_);
                while(!terminate_ && tasks_.empty())
                {
                    taskSync_.wait(locker);
                }
                hasTask = !tasks_.empty();
                proceed = !terminate_;
                needWakeUp = terminate || hasTask; 
 
                if(hasTask)
                {
                    task = tasks_.front();
                    tasks_.pop();
                }
            }
            if(hasTask)
            {
                // здесь выполняем задание из очереди (без блокировки)
               
                 status_.wakeUp(); // будим основной поток если выполнили задание
            }
        }
        std::lock_guard<std::mutex> lock(taskMutex_);
        status_.wakeUp(tasks_.size()); // будим основной поток, если завершаем работу (и снимаем все задания, которое уже были добавлены)
    }
 
private:
    Status & status_;
 
    bool terminate_;
    std::queue<int> tasks_;
 
    std::condition_variable taskSync_;
    std::mutex taskMutex_;
    std::thread thr_;
};

Если что не так, не обессудь. Нет под рукой компилятора.

@NEvOl · 04.11.2014, 21:44 **[ТС]**

блин, ну я никак не могу понять, что я делаю не так ? почему у меня вырубается главный поток и все зависает. Вроде сделал по подобию DrOffset, но что-то не учел.
вот у меня основной цикл проверки, работоспособности:

C++
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
    for (int i = 0; i < 10000; i++)
    {
        x.resize(num);
        y.resize(num);
        z.resize(num);
 
        std::memcpy(&x[0], p + begin, sizeof(XMFLOAT4)*num);
 
        y = z = x;
 
        
#ifdef thQsort
        this->thrs[0]->AddTask(&x[0], num, -2);
        this->mtxCmp.lock();
        this->numTasks++;//изначально numTasks = 0
        this->mtxCmp.unlock();
 
        this->manager.notify_all();
        this->thrs[1]->AddTask(&y[0], num, -2);
        this->mtxCmp.lock();
        this->numTasks++;
        this->mtxCmp.unlock();
 
        this->manager.notify_all();
        this->thrs[2]->AddTask(&z[0], num, -3);
        this->mtxCmp.lock();
        this->numTasks++;
        this->mtxCmp.unlock();
 
        this->manager.notify_all();
        this->WaitToComplete();
#endif
 
#ifdef Qsort
        qSortX(&x[0], num);
        qSortY(&y[0], num);
        qSortZ(&z[0], num);
#endif
 
        switch (++lIndex % 3)
        {
        case 0:
            memcpy(p + begin, &x[0], sizeof(XMFLOAT4)*num);
            break;
        case 1:
            memcpy(p + begin, &y[0], sizeof(XMFLOAT4)*num);
            break;
        case 2:
            memcpy(p + begin, &z[0], sizeof(XMFLOAT4)*num);
            break;
        }
        
        x.clear();
        y.clear();
        z.clear();
    }

рабочая функция такая:

C++
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
void MyThread::workThread()
{
    while (1)
    {
        bool isEmpty = 0;
        {
            std::unique_lock<std::mutex> locker(*this->mtx);//проверяем состояние если размер данных = 0  и если не выключаемся то засыпает поток
            while ((isEmpty = (this->num == 0)) && !(*this->terminate))
                (*this->manager).wait(locker);
        }
        
        if (!isEmpty)//если есть задача
        {
            switch (this->type)
            {
            case -1:
                qSortX(this->pArray, this->num);
                break;
            case -2:
                qSortY(this->pArray, this->num);
                break;
            case -3:
                qSortZ(this->pArray, this->num);
                break;
            }
            this->num = 0;//после выполнения зануляем размер 
            this->CompliteTask();//говорим что одна задача выполнилась
            (*this->isComplite).notify_one();//будит основной поток для проверки
            continue;
        }
        else
        {
            std::unique_lock<std::mutex> locker(*this->mtx);
            if (*(this->terminate))
                return;
        }
            
    }
}
 
void MyThread::CompliteTask()
{
    std::unique_lock<std::mutex> locker(*this->mtxCmp);
    (*this->numTasks)--;//уменьшаем счетчик невыполненных заданий
}

функция ожидания:

C++
1
2
3
4
5
6
7
8
9
void kdTree::WaitToComplete()
{
    std::unique_lock<std::mutex> locker(this->mtxCmp);
    while (this->numTasks)//крутимся пока есть невыполненные задачи
    {
        isComplite.wait(locker);
    }
            
}

Добавлено через 51 минуту
нашел ошибку, при добавлении задачи, нужно использовать блокировку)

Новые блоги и статьи Все статьи Все блоги /
[golang] Breadth-First Search alhaos 19.05.2026 BFS (Breadth-First Search) — это базовый алгоритм обхода графа в ширину, который поуровнево исследует все связанные вершины. Он начинает с выбранной точки и проверяет всех соседей, прежде чем. . .	[golang] Алгоритм «Хак Госпера» alhaos 17.05.2026 Алгоритм «Хак Госпера» Хак Госпера (Gosper's Hack) — алгоритм нахождения следующего по величине числа с тем же количеством установленных бит. Придуман Биллом Госпером в 1970-х, опубликован в. . .	Рисование бинарного древа до 6-го колена на js, svg. russiannick 17.05.2026 <svg width="335" height="240" viewBox="0 0 335 240" fill="#e5e1bb"> <style> <!]> </ style> <g id="bush"> </ g> </ svg> function fn(){ let rost;/ / высота древа let xx=165,yy=210,w=256;	FSharp: interface of module DevAlt 16.05.2026 Интерфейс модуля F# позволяет управлять доступностью членов, содержащихся в реализации модуля. По-умолчанию все члены модуля доступны: module Foo let x = 10 let boo () = printfn "boo" . . .
Хитросплетение родственных связей пантеона греческих богов. russiannick 14.05.2026 Однооконник, позволяющий узреть и изучить отдельных героев древней Греции. <!DOCTYPE html> <html lang="ru"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible". . .	[golang] Угол между стрелками часов alhaos 12.05.2026 По заданным значениям часа и минуты необходимо определить значение меньшего угла между стрелками аналогового циферблата часов. import "math" func angleClock(hour int, minutes int) float64 { . . .	Debian 13: Установка Lazarus QT5 ВитГо 09.05.2026 Эта инструкция моя компиляция инструкций volvo https:/ / www. cyberforum. ru/ blogs/ 203668/ 10753. html и его же старой инструкции по установке Lazarus с gtk2. . .	Нейросеть на алгоритме "эстафета хвоста" как перспектива. Hrethgir 06.05.2026 На десерт, когда запущу сервер. Статья тут https:/ / habr. com/ ru/ articles/ 1030914/ . Автор я сам, нейросеть только помогает в вопросах которые мне не известны - не знаю людей которые знали-бы. . .

@NEvOl 20 / 19 / 1 Регистрация: 13.08.2012 Сообщений: 779
	04.11.2014, 17:40 [ТС]
	DrOffset, я изучал ваш код, а если поток завершит работу до того как функция ожидания будет вызвана ? 0