# 线程管理

在程序开发中，很多时候都是程序都是串行处理，这没有什么问题。然而，在某些重复工作较多，且性能要求较高的场景，串行处理所需时间往往过于漫长。

因此，合理地使用线程管理有助于我们程序的更好运行。但是请注意，不是一味地使用多线程或线程池就一定是好的，适合运行场景的处理方式才是最好的。

# 单线程

在本文中，我们考虑这样一个场景：有一个非常耗时的计算函数，其计算一次需要 time 秒。

1
2
3
4
5
6


void waitTime(int time) {
    std::chrono::seconds duration(time);
    std::this_thread::sleep_for(duration);
    
    std::cout << "wait for " << time << " seconds" << std::endl;
}

按照常规的做法，我们串行地对批量任务进行处理：

1
2
3
4
5
6
7
8
9


int main() {
    std::vector<int> todoList(10, 3);

    for (auto time : todoList) {
        waitTime(time);
    }

    return 0;
}

可以预见，这种处理方法会非常耗时。

# 多线程

为了加速程序运行和处理的速度，我们可以使用多线程来并行处理。多线程的思想是：先将要进行的任务放入队列中，然后让这些任务同时运行，最终实现加速程序运行的效果。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


void mulTreads(std::vector<int> todoList, const int MaxThreads) {
    std::vector<std::unique_ptr<std::thread>> fetchingThreads;

    for (int i = 0, l = todoList.size(); i < l; i ++) {
        fetchingThreads.emplace_back(std::make_unique<std::thread>(waitTime, todoList[i]));

        if (fetchingThreads.size() >= MaxThreads) {
            fetchingThreads.front()->join();
            fetchingThreads.erase(fetchingThreads.begin());
        }
    }

    for (auto &threadPtr : fetchingThreads) {
        threadPtr->join();
    }
}


int main() {
    std::vector<int> todoList(10, 3);
    mulTreads(todoList, 7);

    return 0;
}

# 线程池

多线程虽好，但是频繁地创建和删除线程，同样会造成时间和空间的浪费。因此，线程池出现了，在每次任务完成之后，保留现有线程并继续处理下一个任务。

 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


class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;

                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty())
                            return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }

                    task();
                }
            });
        }
    }

    // 添加任务到线程池
    template<class F>
    void enqueue(F&& task) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace(std::forward<F>(task));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers)
            worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};


int main() {
    const int numThreads = 7;
    ThreadPool pool(numThreads); // 创建包含7个线程的线程池

    std::vector<int> todoList(10, 3);

    // 向线程池中添加任务
    for (const int& time : todoList) {
        pool.enqueue([time] {
            waitTime(time);
        });
    }

    return 0;
}