在C++中，可以使用多線程（例如OpenMP或std::thread）來并行化決策樹的訓練。這里我們將介紹一種基于隨機分層抽樣的并行決策樹訓練方法。以下是一個簡單的實現：

1. 首先，確保你的編譯器支持C++11或更高版本，并且已經安裝了OpenMP庫。

2. 包含必要的頭文件：

#include<iostream>
#include<vector>
#include <ctime>
#include <cstdlib>
#include <omp.h>
#include<thread>

3. 定義一個結構體來表示決策樹節點：

struct TreeNode {
    int feature;
    double threshold;
    int label;
    TreeNode* left;
    TreeNode* right;
};

4. 定義一個函數來計算信息增益：

double calculate_information_gain(const std::vector<int>& labels, const std::vector<int>& left_labels, const std::vector<int>& right_labels) {
    // 計算信息增益的公式
}

5. 定義一個函數來隨機選擇一個特征和閾值：

void random_feature_threshold(const std::vector<std::vector<double>>& features, int num_features, int& feature, double& threshold) {
    feature = rand() % num_features;
    threshold = features[rand() % features.size()][feature];
}

6. 定義一個函數來創建決策樹節點：

TreeNode* create_tree_node(const std::vector<std::vector<double>>& features, const std::vector<int>& labels, int num_features) {
    if (labels.empty()) {
        return nullptr;
    }

    int feature;
    double threshold;
    random_feature_threshold(features, num_features, feature, threshold);

    std::vector<int> left_labels, right_labels;
    for (size_t i = 0; i< features.size(); ++i) {
        if (features[i][feature] <= threshold) {
            left_labels.push_back(labels[i]);
        } else {
            right_labels.push_back(labels[i]);
        }
    }

    TreeNode* node = new TreeNode();
    node->feature = feature;
    node->threshold = threshold;
    node->label = -1;
    node->left = create_tree_node(features, left_labels, num_features);
    node->right = create_tree_node(features, right_labels, num_features);

    return node;
}

7. 定義一個函數來訓練決策樹：

TreeNode* train_decision_tree(const std::vector<std::vector<double>>& features, const std::vector<int>& labels, int num_trees, int num_features) {
    TreeNode* root = nullptr;

    #pragma omp parallel for shared(root)
    for (int i = 0; i < num_trees; ++i) {
        TreeNode* tree = create_tree_node(features, labels, num_features);

        #pragma omp critical
        {
            if (root == nullptr) {
                root = tree;
            } else {
                // 合并決策樹
            }
        }
    }

    return root;
}

8. 最后，在主函數中調用train_decision_tree函數來訓練決策樹：

int main() {
    srand(time(nullptr));

    // 加載數據集
    std::vector<std::vector<double>> features = ...;
    std::vector<int> labels = ...;

    // 訓練決策樹
    int num_trees = 100;
    int num_features = features[0].size();
    TreeNode* root = train_decision_tree(features, labels, num_trees, num_features);

    // 使用決策樹進行預測
    // ...

    return 0;
}

這個實現中，我們使用OpenMP來并行化決策樹的訓練。每個線程都會創建一個決策樹，然后將這些決策樹合并成一個最終的決策樹。注意，這個實現僅示例，你可能需要根據你的需求對其進行修改和優化。