C++多线程

C++对多线程新加的支持操作

 

线程池

  我们有两种常见的创建线程的方法，一种是继承Thread类，一种是实现Runnable的接口，Thread类其实也是实现了Runnable接口。但是我们创建这两种线程在运行结束后都会被虚拟机销毁，如果线程数量多的话，频繁的创建和销毁线程会大大浪费时间和效率，更重要的是浪费内存，因为正常来说线程执行完毕后死亡，线程对象变成垃圾！那么有没有一种方法能让线程运行完后不立即销毁，而是让线程重复使用，继续执行其他的任务哪？我们使用线程池就能很好地解决这个问题。

 直接贴代码吧，代码注释比较详细：

ThreadPool.h

#pragma once
#include <iostream>       // std::cout
#include <functional>     // std::ref
#include <thread>         // std::thread
#include <future>         // std::promise, std::future
#include <mutex>
#include <queue>
#include <condition_variable>
#include <atomic>
#include <cassert>

using namespace std;

#define MAXTHREADNUM 10 // 设置最大线程数量
typedef function<void()> Task; // 任务模板函数


namespace ThreadPool {
    class ThreadPool
    {
    private:
        queue<Task> tasks_queue; // 任务队列
        vector<thread> thread_pool; // 线程池
        atomic<bool> is_stop; // 释放关闭提交
        atomic<int> idle_thread_num; // 空闲线程数量
        mutex mu; // 互斥锁
        condition_variable cv; // 条件变量

        /* 公有方法 */
    public:
        // 构造函数：
        ThreadPool(int size = MAXTHREADNUM) :is_stop(false)
        {
            size = size > MAXTHREADNUM ? MAXTHREADNUM : size;
            idle_thread_num = size;
            for (int i = 0; i < size; ++i)
            {
                // 在线程池中创建指定数量的线程，这里用emplace是为了提供效率，相比insert，emplace不必创建中间的临时变量
                thread_pool.emplace_back(&ThreadPool::scheduler, this);
            }
        }

        // 析构函数：
        ~ThreadPool()
        {
            close(); // 首先停止线程池的提交
            while (!tasks_queue.empty()) // 将任务队列清空
            {
                tasks_queue.pop();
            }
            cv.notify_all();
            for (auto& th : thread_pool) // 结束前将所有线程join，阻塞主进程，防止线程中用到共享资源
            {
                if (th.joinable())
                    th.join();
            }
            thread_pool.clear(); // 清空线程池
        }

        // 重新打开线程池：
        void re_open()
        {
            if (is_stop.load())is_stop.store(false);
            cv.notify_all(); // 唤醒所有线程
        }

        // 关闭线程池：
        void close()
        {
            if (!is_stop.load())is_stop.store(true);
        }

        // 是否已停止提交任务：
        bool is_closed() const
        {
            return is_stop.load();
        }

        // 获取空闲线程数量：
        int get_idle_thread_num()
        {
            return idle_thread_num;
        }

        // 获取任务队列size：
        rsize_t get_task_num()
        {
            return tasks_queue.size();
        }

        // 提交新任务到任务队列：
        template<class F, class... Args>
        auto submit(F&& f, Args&&... args)->std::future<decltype(f(args...))>
        {
            if (is_stop.load()) {
                throw std::runtime_error("ThreadPool is closed, can not submit task.");
            }

            // 对提交的任务函数与 task 类型做适配
            using RetType = decltype(f(args...));  // typename std::result_of<F(Args...)>::type, 函数 f 的返回值类型
            std::shared_ptr<std::packaged_task<RetType()>> task = std::make_shared<std::packaged_task<RetType()>>(
                std::bind(std::forward<F>(f), std::forward<Args>(args)...)
                );
            std::future<RetType> future = task->get_future();

            // 封装任务并添加到队列
            add_task([task]() {
                (*task)();
                });

            return future;
        }

        /* 私有方法 */
    private:
        // 从任务队列获取一个任务
        Task get_task()
        {
            unique_lock<mutex> lck(mu); // unique_lock 与 lock_guard的区别是，unique_lock 可以随时加锁 解锁，在cv.wait()时加锁，唤醒后自动解锁
            while (tasks_queue.empty() && !is_stop.load()) // 线程池未停止，但是任务队列为空
            {
                cv.wait(lck); // 一直等到任务队列来任务
            }
            if (is_stop.load()) // 线程池已经停止
                return Task(); // 返回一个空的任务
            assert(!tasks_queue.empty()); // 断言 任务队列不为空
            Task task = move(tasks_queue.front()); // 从队首取出一个任务
            tasks_queue.pop();
            cv.notify_one(); // 唤醒一个进程来处理取出来的任务
            return task;
        }

        // 添加任务到任务队列
        void add_task(Task task)
        {
            // 此处需要加锁，queue不是线程安全的
            lock_guard<mutex> lkc{ mu }; // lock_guard 构造函数中加锁，析构函数中解锁
            tasks_queue.push(task);
            cv.notify_one();
        }

        // 主调度函数，线程执行的函数
        void scheduler()
        {
            while (!is_stop.load())
            {
                Task task(get_task());
                if (task)
                {
                    idle_thread_num--; // 空闲线程数 -1
                    task();
                    idle_thread_num++; // 执行完任务，此线程又变为空闲
                }
            }
        }

    };
}

main.cpp  测试函数

#include "ThreadPool.h"
#include <chrono>

int test1(int num)
{
    this_thread::sleep_for(chrono::seconds(1));
    cout << "test1: " << num << endl;
    return ((num == 0) ? 0 : num / 2);
}


int test2(int num1, int num2)
{
    this_thread::sleep_for(chrono::seconds(1));
    cout << "test2: " << num1 << " " << num2 << endl;
    return 1000;
}


int main()
{
    ThreadPool::ThreadPool workers(3); // 创建一个有10个线程的线程池

    // 输出开始状态：
    std::cout << "at the beginning: " << std::endl;
    std::cout << "idle threads: " << workers.get_idle_thread_num() << std::endl;
    std::cout << "tasks: " << workers.get_task_num() << std::endl;

    future<int>submit1 = workers.submit(test1, 10); // 提交一个任务

    std::cout << "after 1 sunmit: " << std::endl;
    std::cout << "idle threads: " << workers.get_idle_thread_num() << std::endl;
    std::cout << "tasks: " << workers.get_task_num() << std::endl;

    future<int>submit2 = workers.submit(test1, 20); // 提交一个任务

    std::cout << "after 2 sunmit: " << std::endl;
    std::cout << "idle threads: " << workers.get_idle_thread_num() << std::endl;
    std::cout << "tasks: " << workers.get_task_num() << std::endl;

    future<int>submit3 = workers.submit(bind(test2,1,2)); // 提交一个任务

    std::cout << "after 3 sunmit: " << std::endl;
    std::cout << "idle threads: " << workers.get_idle_thread_num() << std::endl;
    std::cout << "tasks: " << workers.get_task_num() << std::endl;

    cout << submit1.get() << endl;
    cout << submit2.get() << endl;
    cout << submit3.get() << endl;
    std::cout << "end: " << std::endl;
    std::cout << "idle threads: " << workers.get_idle_thread_num() << std::endl;
    std::cout << "tasks: " << workers.get_task_num() << std::endl;
    return 0;
}

面试题

1.题目：子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码

#include <iostream>             // std::cout
#include <mutex>
#include <thread>         // std::thread
#include <condition_variable>

using namespace std;

mutex mu;
int flag = 10;
condition_variable cv;
void f(int num)
{
    for (int i = 0; i < 50; i++)
    {
        unique_lock<mutex> lk(mu); 
        while (flag != num) // 这里不能用if，一定要用while
            cv.wait(lk); // 条件变量调用wait会自动调用锁
        for (int j = 0; j < num; ++j)
        {
            cout << j << " ";
        }
        cout << endl;
        flag = (num == 10) ? 100 : 10;
        cv.notify_one();
    }
}

int main()
{
    thread child(f, 10);
    f(100);
    child.join();
    return 0;
}

2.编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推

#include <iostream>             // std::cout
#include <mutex>
#include <thread>         // std::thread
#include <condition_variable>

using namespace std;

mutex mu;
int flag = 0;
condition_variable cv;
void f(int num)
{
    for (int i = 0; i < 10; i++)
    {
        unique_lock<mutex> lk(mu); 
        while (flag != num) // 这里不能用if 一定要用while
            cv.wait(lk); // 条件变量调用wait会自动调用锁
        char c = 'A' + flag;
        cout << c;
        flag = (flag+1)%3;
        cv.notify_all(); //唤醒其他进程
    }
}

int main()
{
    thread child1(f, 0);
    thread child2(f, 1);
    f(2);
    child1.join();
    child2.join();
    return 0;
}

3.题目(google笔试题)：有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：

A：1 2 3 4 1 2....
B：2 3 4 1 2 3....
C：3 4 1 2 3 4....

D：4 1 2 3 4 1....

#include <iostream>             // std::cout
#include <mutex>
#include <thread>         // std::thread
#include <condition_variable>

using namespace std;

mutex mu;
int flag = 0; // 改变flag的值，就改变了1234的输出顺序
condition_variable cv;

void f(int num)
{
    for (int i = 0; i < 100; i++)
    {
        unique_lock<mutex> lk(mu); 
        while (flag != num)
            cv.wait(lk); // 条件变量调用wait会自动调用锁
        cout << num + 1 << " ";
        flag = (flag + 1) % 4;
        cv.notify_all(); //唤醒其他进程
    }
}

int main()
{
    thread child1(f, 0);
    thread child2(f, 1);
    thread child3(f, 2);
    f(3);

    child1.join();
    child2.join();
    child3.join();
    cout << endl;

    //system("pause");
    return 0;
}

4.读写者问题：这也是一个非常经典的多线程题目，题目大意如下：有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者去读文件，同样有读者读时写者也不能写

class rwlock {
private:
    mutex _lock;
    condition_variable _wcon, _rcon; // 写者和读者的条件变量
    unsigned _writer, _reader; // 分别表示写者和读者数量
    int _active; // -1：有写者正在写   0:没有读者也没有写者    大于0：有读者在读，且等于读者数量
public:
    void read_lock() {
        unique_lock<mutex> lock(_lock);
        ++_reader;
        while (_active < 0 || _writer > 0) // 在有写者存在时，读者挂起
            _rcon.wait(lock);
        --_reader;
        ++_active;
    }
    void write_lock() {
        unique_lock<mutex> lock(_lock);
        ++_writer;
        while (_active != 0) // 在有读者或者写者存在读或者在写时，写者挂起
            _wcon.wait(lock);
        --_writer;
        _active = -1;
    }
    void unlock() { // 主要是对 _active 变量进行恢复
        unique_lock<mutex> lock(_lock);
        if (_active > 0) { // 要解锁的是读者
            --_active;
            if (_active == 0) _wcon.notify_one();
        }
        else { // 要解锁的是写者
            _active = 0;
            if (_writer > 0) _wcon.notify_one(); // 此时若写者数量不为0（有其他写者在等待）
            else if (_reader > 0) _rcon.notify_all(); // 此时没有写者等待，只有读者等待，则唤醒所有读者
        }

    }
    rwlock() :_writer(0), _reader(0), _active(0) {
    }
};

void t1(rwlock* rwl) {
    while (1) {
        cout << "I want to write." << endl;
        rwl->write_lock();
        cout << "writing..." << endl;
        this_thread::sleep_for(chrono::seconds(5));
        rwl->unlock();
        this_thread::sleep_for(chrono::seconds(5));
    }
}

void t2(rwlock* rwl) {
    while (1) {
        cout << "t2-I want to read." << endl;
        rwl->read_lock();
        cout << "t2-reading..." << endl;
        this_thread::sleep_for(chrono::seconds(1));
        rwl->unlock();
    }
}

void t3(rwlock* rwl) {
    while (1) {
        cout << "t3-I want to read." << endl;
        rwl->read_lock();
        cout << "t3-reading..." << endl;
        this_thread::sleep_for(chrono::seconds(1));
        rwl->unlock();
    }
}

int main()
{
    rwlock* rwl = new rwlock();
    thread th1(t1, rwl);
    thread th2(t2, rwl);
    thread th3(t3, rwl);
    th1.join();
    th2.join();
    th3.join();

    system("pause");
    return 0;
}