***同一进程间的线程共享的资源***包括：
1、堆：由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的。
2、全局变量：它是与具体某一函数无关的，所以也与特定线程无关；因此也是共享的。
3、静态变量： 虽然对于局部变量来说，它在代码中是"放"在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的．bss和．data 段，是共享的。
4、文件等公用资源：使用这些公共资源的线程必须同步。
Win32 提供了几种同步资源的方式，包括信号、临界区、事件和互斥体。

***线程独享的资源***有：
1、栈：每个线程中的栈都是由线程自身独享的。
2、寄存器：每个线程执行指令时，都要用到寄存器，线程间的寄存器并不共享。

以下是一个C++示例，演示同一进程中的线程共享堆、全局变量、静态变量和文件资源，同时各自独享栈和寄存器：

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

// 2. 全局变量（共享）
int global_var = 0;

// 3. 静态变量（共享）
static int static_var = 0;

// 同步用的互斥量
std::mutex mtx;

// 1. 堆内存（共享）
struct SharedData {
    int value;
    std::vector<int> vec;
};

void thread_function(int id) {
    // 每个线程独享的栈变量（不共享）
    int stack_var = id; // 栈变量

    // 使用共享资源
    
    // 1. 访问堆内存
    static SharedData* shared_data = new SharedData{0, {1, 2, 3}};
    shared_data->value += 1;
    shared_data->vec.push_back(stack_var);

    // 2. 修改全局变量
    global_var += 1;

    // 3. 修改静态变量
    static_var += 1;

    // 4. 文件操作（需要同步）
    {
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "Thread " << id << " writing to file..." << std::endl;
        // 实际文件操作这里省略...
    }

    // 演示栈独享（每个线程的stack_var值不同）
    std::cout << "Thread " << id << " stack_var: " << stack_var 
              << " (address: " << &stack_var << ")" << std::endl;
}

int main() {
    const int NUM_THREADS = 3;
    std::vector<std::thread> threads;

    // 创建多个线程
    for (int i = 0; i < NUM_THREADS; ++i) {
        threads.emplace_back(thread_function, i);
    }

    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }

    // 输出共享资源的最终值
    std::cout << "\nFinal shared resources:" << std::endl;
    std::cout << "global_var: " << global_var << std::endl;
    std::cout << "static_var: " << static_var << std::endl;
    std::cout << "shared_data->value: " << shared_data->value << std::endl;
    std::cout << "shared_data->vec size: " << shared_data->vec.size() << std::endl;

    // 清理堆内存
    delete shared_data;

    return 0;
}

关键点说明：

1. 共享资源：

   • 堆：所有线程通过new分配的SharedData对象

   • 全局变量：global_var被所有线程修改

   • 静态变量：static_var被所有线程修改

   • 文件资源：通过std::cout演示需要同步的输出（实际文件操作需要更严格的同步）

2. 独享资源：

   • 栈：每个线程的stack_var有不同值和地址

   • 寄存器：线程切换时会自动保存/恢复寄存器状态（通过编译器自动处理）

3. 同步机制：

   • 使用std::mutex保护对共享资源（如std::cout）的访问

   • 如果没有同步，多个线程同时输出会导致交错混乱

可能的输出示例：

Thread 0 stack_var: 0 (address: 0x7ffde8e1a3fc)Thread 1 stack_var: 1 (address: 0x7ffde86193fc)Thread 2 stack_var: 2 (address: 0x7ffde7e183fc)Final shared resources:global_var: 3static_var: 3shared_data->value: 3shared_data->vec size: 6

注意：由于线程调度顺序不确定，每次运行的具体数值可能不同，但最终共享变量的总和应该等于线程数量的累加（本例中每个线程对共享变量+1，3个线程共+3）。