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

@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 минуту
нашел ошибку, при добавлении задачи, нужно использовать блокировку)

Новые блоги и статьи Все статьи Все блоги /
Транслитерация текста с кириллицы на латиницу (вариант №2) Maks 13.11.2026 Обновленная версия ранее созданной обработки. Добавлено: - Проверка исходного текста на кириллицу, через обращение к стандартной функции "ТолькоКириллицаВСтроке" из общего модуля. . .	Часы с термометром и праздничным календарем yariko 12.11.2026 Сегодня мы рассмотрим как можно сделать отличные многофункциональные часы. Итак, поставим конкретную задачу: разработать часы с календарем, двумя термодатчиками, выводом поздравительных сообщений. . .	Транслитерация текста с кириллицы на латиницу (вариант №1) Maks 11.11.2026 Решил облегчить жизнь себе и коллегам админам при создании электронных почтовых ящиков для пользователей, в результате написал обработку "Транслитерация текста" с кириллицы на латиницу, а в ней. . .	Книги по геймдизайну, левел-дизайну, игровым механикам и проектированию игрового опыта 8Observer8 08.11.2026 Содержание блога \| English Version 1. 2003 - 06 - Designing Virtual Worlds (1st Edition) Автор: Richard A. Bartle \| Объем: 768 стр. Ссылки: Amazon . . .
Родители токсичные абьюзеры по отношению к своим детям ругают их оскорбляют не любят zorxor 08.11.2026 Жить в атмосфере постоянных оскорблений, критики и холодности со стороны родителей — это тяжелое и болезненное испытание, которое оставляет глубокие эмоциональные раны. Токсичное и абьюзивное. . .	Как только я захожу к себе в свою комнату я сразу же с себя снимаю свои трусы. Ответ от Джемени ИИ. zorxor 08.11.2026 Джемени, как только я захожу к себе в свою комнату я сразу же с себя снимаю свои трусы. Многие люди, возвращаясь домой, сразу переодеваются в максимально свободную одежду или вовсе предпочитают. . .	Паттерн очереди действий/команд (Action / Command Queue). Система очереди действий и кат-сцен с SDL3 Callbacks, cglm и OpenGL 8Observer8 07.11.2026 Содержание блога \| English Version Руководство для начинающих по реализации паттерна очереди действий/ команд (Action / Command Queue) на C++ (C++20) с использованием официального SDL3 Callbacks. . .	Проверка полного ФИО в типовом справочнике Maks 07.11.2026 Решение реализовано в конфигурации КА2, на примере справочника "КонтактныеЛицаПартнеров". Задача: Запрет инициалов. Не допускаеть использование сокращений вида "И. И. ", "И. И. ", "И И" и. . .

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