vc多线程操作数据库

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

class DBConnectionPool {
public:
    DBConnectionPool(int size) {
        for (int i = 0; i < size; ++i) {
            connections.push(createConnection());
        }
    }

    ~DBConnectionPool() {
        while (!connections.empty()) {
            delete connections.front();
            connections.pop();
        }
    }

    void getConnection(std::unique_lock<std::mutex>& lock) {
        condVar.wait(lock, [this] { return !connections.empty(); });
        auto conn = connections.front();
        connections.pop();
        lock.unlock();
        return conn;
    }

    void releaseConnection(DBConnection* conn) {
        std::unique_lock<std::mutex> lock(mutex);
        connections.push(conn);
        lock.unlock();
        condVar.notify_one();
    }

private:
    DBConnection* createConnection() {
        // 创建数据库连接的逻辑
        return new DBConnection();
    }

    std::queue<DBConnection*> connections;
    std::mutex mutex;
    std::condition_variable condVar;
};

void workerThread(DBConnectionPool& pool) {
    std::unique_lock<std::mutex> lock(pool.mutex);
    auto conn = pool.getConnection(lock);
    // 使用连接进行数据库操作
    pool.releaseConnection(conn);
}

int main() {
    DBConnectionPool pool(10);
    std::vector<std::thread> threads;
    for (int i = 0; i < 20; ++i) {
        threads.emplace_back(workerThread, std::ref(pool));
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

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

std::mutex mtx;
int sharedData = 0;

void threadFunc() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++sharedData;
    }
}

int main() {
    std::thread t1(threadFunc);
    std::thread t2(threadFunc);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << sharedData << std::endl;
    return 0;
}

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

std::mutex mtx;
void transactionFunc() {
    std::lock_guard<std::mutex> lock(mtx);
    // 开始数据库事务
    // 执行数据库操作
    // 提交或回滚事务
}

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