c++多线程

C++多线程是指在C++程序中使用多个执行线程来并行执行任务的编程技术。多线程可以充分利用多核处理器和并行计算资源，提高程序的性能和响应速度。C++标准库提供了一套丰富的多线程支持，使得开发者可以方便地创建、管理和同步线程。

1. 创建多线程：

C++11引入了std::thread类，允许程序创建和管理线程。使用std::thread，您可以启动新的线程并执行指定的函数，也可以传递参数给函数。线程执行完毕后，可以通过join()或detach()来等待线程结束或者将线程与程序分离。

1.1. 函数指针：可以将一个函数指针传递给线程构造函数，从而创建一个线程执行指定的函数

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "This is a thread function\n";
}

int main() {
    std::thread t(threadFunction);
    t.join();
    return 0;
}

1.2. Lambda 表达式：可以直接在线程构造函数中使用 lambda 表达式，而不必事先定义一个函数

#include <iostream>
#include <thread>

int main() {
    std::thread t([](){
        std::cout << "This is a thread function\n";
    });
    t.join();
    return 0;
}

1.3. 可调用对象：除了函数指针和 lambda 表达式外，您还可以使用可调用对象（例如函数对象、成员函数指针等）来创建线程。

#include <iostream>
#include <thread>

class MyClass {
public:
    void operator()() const {
        std::cout << "This is a thread function\n";
    }
};

int main() {
    MyClass obj;
    std::thread t(obj);
    t.join();
    return 0;
}

1.4. 使用成员函数指针：可以使用成员函数指针以及对象实例来创建线程。

#include <iostream>
#include <thread>

class MyClass {
public:
    void memberFunction() {
        std::cout << "This is a member function\n";
    }
};

int main() {
    MyClass obj;
    std::thread t(&MyClass::memberFunction, &obj);
    t.join();
    return 0;
}

1.5. 使用函数对象的 std::async：std::async函数可以异步执行函数，并返回一个 std::future 对象，它可以用来获取函数执行的结果

#include <iostream>
#include <future>

int threadFunction() {
    std::cout << "This is a thread function\n";
    return 42;
}

int main() {
    std::future<int> result = std::async(std::launch::async, threadFunction);
    int value = result.get();
    std::cout << "Returned value: " << value << std::endl;
    return 0;
}

2. 多线程同步：

多个线程访问共享数据时可能会引发竞态条件和数据竞争问题，因此需要进行线程同步。C++标准库提供了各种同步原语，例如互斥锁（std::mutex）、条件变量（std::condition_variable）、原子操作（std::atomic）等，来保护共享资源的访问，避免并发访问导致的问题。

2.1. 互斥锁（Mutex）：

互斥锁是一种最基本的同步机制，用于保护共享资源免受并发访问。一次只允许一个线程持有互斥锁，其他线程必须等待锁的释放才能继续执行。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void threadFunction() {
    mtx.lock();
    // 访问共享资源
    mtx.unlock();
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    return 0;
}

2.2. 条件变量（Condition Variable）：

条件变量允许一个或多个线程等待某个条件成立。它通常与互斥锁一起使用，以允许线程在条件不满足时等待，在条件满足时被唤醒。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void consumerFunction() {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) {
        cv.wait(lock); // 等待条件变量
    }
    // 使用共享资源
}

void producerFunction() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true; // 修改共享资源
    }
    cv.notify_one(); // 唤醒一个等待线程
}

int main() {
    std::thread consumerThread(consumerFunction);
    std::thread producerThread(producerFunction);
    consumerThread.join();
    producerThread.join();
    return 0;
}

2.3. 原子操作（Atomic Operations）：

原子操作是不可分割的操作，可以保证在多线程环境下的线程安全性。C++标准库提供了一系列原子类型，允许对它们进行原子读写操作。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> atomicCounter(0);

void threadFunction() {
    atomicCounter++; // 原子操作
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    std::cout << "Atomic counter: " << atomicCounter << std::endl;
    return 0;
}

2.4. 信号量（Semaphore）：

信号量是一种计数器，用于控制对一组资源的访问。当信号量大于零时，线程可以访问资源并将信号量减一；当信号量等于零时，线程将被阻塞直到信号量大于零。

#include <iostream>
#include <thread>
#include <semaphore.h>

sem_t semaphore;

void threadFunction() {
    sem_wait(&semaphore); // 等待信号量
    // 访问共享资源
    sem_post(&semaphore); // 释放信号量
}

int main() {
    sem_init(&semaphore, 0, 1); // 初始化信号量
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    sem_destroy(&semaphore); // 销毁信号量
    return 0;
}

3. 线程池：

线程池是一种并发编程的技术，用于管理和重用线程，以提高多线程程序的性能和效率。线程池通常在程序启动时创建一组线程，并在需要执行任务时将任务提交给线程池中的线程执行，而不是每次任务都创建新线程。这样可以减少线程的创建和销毁开销，并提高系统的响应速度和资源利用率。

这是一个简单的线程池代码案例：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

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&& f) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace(std::forward<F>(f));
        }
        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;
};

// 使用线程池计算斐波那契数列

long long fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

int main() {
    ThreadPool pool(4); // 创建线程池，包含4个线程

    for (int i = 0; i < 10; ++i) {
        pool.enqueue([i] {
            std::cout << "Fibonacci(" << i << ") = " << fib(i) << std::endl;
        });
    }

    return 0;
}

在这个例子中，ThreadPool类实现了一个简单的线程池，包含了指定数量的工作线程。主程序使用线程池计算斐波那契数列的值，每个计算任务被提交到线程池中，由线程池中的工作线程执行。这样可以充分利用系统资源，提高计算效率。