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

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

Новые блоги и статьи Все статьи Все блоги /
Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Programma_Boinc 28.12.2025 Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Налог на собак: https:/ / ********/ gallery/ V06K53e Финансовый отчет в Excel: https:/ / ********/ gallery/ bKBkQFf Пост отсюда. . .	Кто-нибудь знает, где можно бесплатно получить настольный компьютер или ноутбук? США. Programma_Boinc 26.12.2025 Нашел на реддите интересную статью под названием Anyone know where to get a free Desktop or Laptop? Ниже её машинный перевод. После долгих разбирательств я наконец-то вернула себе. . .	Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Programma_Boinc 23.12.2025 Рецензия / Мнение/ Перевод Нашел на реддите интересную статью под названием The Thinkpad X220 Tablet is the best budget school laptop period . Ниже её машинный перевод. Thinkpad X220 Tablet —. . .	PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Как объединить две одинаковые БД Access с разными данными VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.
Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .	Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .

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