多线程介绍

1. 堆（Heap）
   定义：堆是用于动态内存分配的区域，程序可以在运行时请求和释放内存。
   数量：每个进程通常只有一个堆，但可以在这个堆中分配多个内存块。堆的大小可以根据需要动态增长。
   管理：堆内存的管理通常由程序员通过 malloc、calloc、realloc 和 free 等函数进行。
2. 栈（Stack）
   定义：栈是用于存储函数调用的局部变量、参数和返回地址的区域。每当一个函数被调用时，都会在栈上分配一个新的栈帧。
   数量：每个进程通常只有一个主栈，但每个线程都有自己的栈。对于多线程程序，每个线程都有独立的栈空间。
   管理：栈内存的管理是自动的，函数调用时自动分配栈帧，函数返回时自动释放。
   总结
   单个进程：一个进程通常有一个堆和一个主栈。
   多线程：在多线程程序中，每个线程都有自己的栈，但仍然共享同一个堆。
   因此，虽然一个进程通常只有一个堆和一个主栈，但在多线程环境中，每个线程都有自己的栈。

在多线程环境中，进程的内存分配机制对于堆和栈的管理有着重要的影响。以下是关于一个进程中不同线程的堆和栈分配的详细说明：

1. 堆（Heap）
   共享堆：

在一个进程中，所有线程共享同一个堆内存区域。这意味着在同一个进程中的不同线程可以动态分配和释放堆内存。

由于堆是共享的，多个线程可以同时访问和修改堆中的数据，这可能导致数据竞争和不一致性的问题。

线程安全：

在多线程环境中，使用堆内存时需要注意线程安全。通常需要使用互斥锁（mutex）或其他同步机制来保护对共享堆内存的访问，以避免竞争条件和数据损坏。

2. 栈（Stack）
   独立栈：

每个线程在创建时都会分配自己的栈空间。栈用于存储线程的局部变量、函数参数和返回地址。

由于每个线程有独立的栈，因此线程之间的局部变量是相互隔离的，不会相互影响。

栈大小：

每个线程的栈大小通常在创建线程时指定，默认大小可能因操作系统和编程语言而异。过大的递归调用可能导致栈溢出。

3. 线程的内存分配示例
   堆的使用：

线程 A 和线程 B 可以同时在堆中分配内存。例如，线程 A 使用 malloc 分配内存，线程 B 也可以使用 malloc 分配内存，但需要确保对共享数据的访问是安全的。

栈的使用：

线程 A 和线程 B 各自的栈中可以有相同名称的局部变量，但它们是独立的。例如：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void* threadFunction(void* arg) {
 int localVar = *((int*)arg); // 每个线程的局部变量
 printf("Thread %ld: localVar = %d\n", pthread_self(), localVar);
 return NULL;
}

int main() {
 pthread_t threadA, threadB;
 int valueA = 10;
 int valueB = 20;

 // 创建线程 A
 if (pthread_create(&threadA, NULL, threadFunction, &valueA) != 0) {
     perror("Failed to create thread A");
     return 1;
 }

 // 创建线程 B
 if (pthread_create(&threadB, NULL, threadFunction, &valueB) != 0) {
     perror("Failed to create thread B");
     return 1;
 }

 // 等待线程 A 和线程 B 完成
 pthread_join(threadA, NULL);
 pthread_join(threadB, NULL);

 return 0;
}

在多线程环境中，所有线程共享同一个堆内存区域，而每个线程都有自己的独立栈。堆的共享特性要求在访问时注意线程安全，而栈的独立性使得线程之间的局部变量不会相互干扰。这种内存管理机制对于多线程编程的正确性和效率至关重要。
以下是一个使用互斥锁（mutex）来保护共享堆内存的示例代码，确保在多个线程访问共享数据时不会发生数据竞争。

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define ARRAY_SIZE 10

// 共享数组
int *sharedArray;
pthread_mutex_t mutex; // 互斥锁

// 线程函数
void* threadFunction(void* arg) {
  int thread_id = *((int*)arg);
  
  // 对共享数组的访问需要加锁
  for (int i = 0; i < ARRAY_SIZE; i++) {
      pthread_mutex_lock(&mutex); // 加锁
      sharedArray[i] += thread_id; // 更新共享数组
      pthread_mutex_unlock(&mutex); // 解锁
  }
  
  printf("Thread %d finished updating the array.\n", thread_id);
  return NULL;
}

int main() {
  pthread_t threads[3];
  int thread_ids[3];

  // 动态分配共享数组
  sharedArray = malloc(ARRAY_SIZE * sizeof(int));
  if (sharedArray == NULL) {
      perror("Failed to allocate memory");
      return 1;
  }

  // 初始化共享数组
  for (int i = 0; i < ARRAY_SIZE; i++) {
      sharedArray[i] = i; // 初始化为 0, 1, 2, ..., 9
  }

  // 初始化互斥锁
  pthread_mutex_init(&mutex, NULL);

  // 创建多个线程
  for (int i = 0; i < 3; i++) {
      thread_ids[i] = i + 1; // 线程 ID 从 1 开始
      if (pthread_create(&threads[i], NULL, threadFunction, &thread_ids[i]) != 0) {
          perror("Failed to create thread");
          return 1;
      }
  }

  // 等待所有线程完成
  for (int i = 0; i < 3; i++) {
      pthread_join(threads[i], NULL);
  }

  // 打印共享数组的最终状态
  printf("Final state of shared array:\n");
  for (int i = 0; i < ARRAY_SIZE; i++) {
      printf("%d ", sharedArray[i]);
  }
  printf("\n");

  // 清理资源
  pthread_mutex_destroy(&mutex); // 销毁互斥锁
  free(sharedArray); // 释放共享数组的内存
  return 0;
}