多线程内存管理

  原文：http://yachang.wang.blog.163.com/blog/static/35551220200762753057335/

  假设有一个进程，创建了两个线程A、B，线程A在堆上分配了一块内存空间，通知传指针的方式在B中使用，使用完后释放块，这时就会出错，因为线程B不能释放线程A堆上的内存空间，一些网友对此也有一些看法。

       “有点经验可以告诉你，每个线程都有自己的堆栈，而它们共享进程的一个全局堆，NEW是在线程的局部堆上分配（实际上每个函数都是这样），在线程中用 new分配的内存不能在另一个线程中用delete删除（因为这两个函数都只能处理自己的堆）要完成这个功能必须用HeapAlloc函数在全局堆上进行 操作。至于内存管理我的感觉是看看编译原理，尤其是影印版的会很清楚，因为程序运行中内存的动态分配操作系统的书籍 只是从系统管理的角度来阐述的，是一个问题的两个方面。”

       “在程序启动的时候把你要NEW的内存NEW成一个链表放起来，比如先NEW一个链表，结点就是要用的内存，然后在需要用的时候从链表里取一个出来，用完了放回链表 最后程序退出的时候销毁这个链表。去找找有关内存池的资料吧”

        “_beginthread(ex)与CreateThread的主要不同是对C标准库函数的支持不同，在CreateThread中使用C标准库函数是 不安全的（据M$的说法，如果CreateThread线程创建失败，使用C标准库函数会导致少量内存泄漏，但总而言之，不够安全）。Win32中C++ 算符new/delete实际上是通过在进程全局堆中分配实现的，如果为安全性考虑，可以用HeapCreate创建局部堆，然后通过HeapAlloc /HeapFree分配，这样如果有某些错误的话（如数组越界）不至于影响到全局堆中的数据。我个人觉得的用AfxBeginThread()对C++的 语法支持较好，而且它内部调用的是_beginthreadex,   可是他返回的是CWinThread对象的指针，可能对你不太适用。”

        “同一进程内的所有线程共享进程地址空间，每个线程有独立的堆栈，一个线程可以访问另一个线程的堆。”

        “第一次听到线程堆栈的地址空间这个叫法，所以恕我不能明白你的意思。在很多现代操作系统中，一个进程的（虚）地址空间大小为4G，分为系统（内核？）空 间和用户空间两部分，系统空间为所有进程共享，而用户空间是独立的，一般WINDOWS进程的用户空间为2G。   
          一个进程中的所有线程共享该进程的地址空间，但它们有各自独立的（/私有的）栈(stack)，Windows线程的缺省堆栈大小为1M。堆 (heap)的分配与栈有所不同，一般是一个进程有一个C运行时堆，这个堆为本进程中所有线程共享，windows进程还有所谓进程默认堆，用户也可以创 建自己的堆。用操作系统术语，线程切换的时候实际上切换的是一个可以称之为线程控制块的结构（TCB?）,里面保存所有将来用于恢复线程环境必须的信息，包括所有必须保存的寄存器集，线程的状态等。 ”

        “有关内存管理问题，很多书上都有比较详尽的介绍，基本上也就如wzwind(风的脚印)所述。内存分配主要分为堆栈(stack)内存分配和堆 (heap)内存分配。当你定义了一个局部变量时，系统会自动在堆栈中为该变量分配空间，当程序运行到堆栈变量的作用范围之外时，空间会自动释放。而堆则 是在程序代码段 和堆栈之外的内存段，这部分的内存是可以动态分配的，需要程序员来管理（分配和释放）。对于同一个进程的多个线程而言，它们之间是共享同一内存空间的，虽 然每个线程都有自己的堆栈，但它们使用同一块堆。你可以把线程理解为一个函数或过程，它可以有自己的局部变量，而用new分配的变量相当于全局变量，可供 同一进程的其它线程共享，所以线程退出后，应及时释放，否则这段空间就一直被你占用着。”

        根据CSDN上网友的看法，在查阅了相关书籍但做了代码测试的基础上，我也在这里提出自己的观点。

1. 首先要澄清的是堆栈（STACK）和堆（HEAP）的区别，中文将STACK译为“堆栈”我个人认为不是很科学，不如直接译为“栈”，这样与 HEAP更容易区分。这里讨论的栈与堆是操作系统层面的，栈是系统自动管理与分配的内存资源，分配与回收的效率高，常用于函数调用时参数传递，在线程切换 时要进行栈切换；堆由程序员自行分配与释放，C++中用NEW与DELETE分配与释放，在堆上分配与回收内存更灵活，但是效率与栈操作低了一点，并且一 定要注意回收，不然会导致内存泄漏。
2. 一个进程有一个全局的HEAP，创建的每个线程都有自己的STACK，线程创建时可以自定义栈大小，默认情况下WIN32是1MB，所以线程间是栈安全的，这样，在一个线程中分配的内存可以在另一个线程中释放，后面我会给出代码验证。
3. 在下面的代码中，我会创建两个线程，一个全局的Buffer，采用FIFO队列实现，一个线程向队列中写数据，一个线程从线程中读数据，采用事件通知策略，用条件互斥量避免数据竞争。

#include <process.h>
#include <windows.h>
#include <queue>
#include <stdio.h>

using namespace std;

DWORD WINAPI ThreadWrite(LPVOID lParam);
DWORD WINAPI ThreadRead(LPVOID lParam);

queue<char *> Buffer;

HANDLE m_hMutexBuffer;
HANDLE m_hEventBuffer;

void main()
{
 m_hMutexBuffer = CreateMutex(NULL, FALSE, NULL);
 ReleaseMutex(m_hMutexBuffer);

 m_hEventBuffer = CreateEvent(NULL, TRUE, FALSE, NULL);
 
 HANDLE m_hThreadWrite = CreateThread(NULL, 0, ThreadWrite, NULL, 0, 0);
 HANDLE m_hThreadRead  = CreateThread(NULL, 0, ThreadRead,  NULL, 0, 0);
 
 HANDLE HandleList[2];
 HandleList[0] = m_hThreadWrite;
 HandleList[1] = m_hThreadRead;
 
 WaitForMultipleObjects(2, HandleList, TRUE, INFINITE);
}

DWORD WINAPI ThreadWrite(LPVOID lParam)
{
 if (WAIT_OBJECT_0 == WaitForSingleObject(m_hMutexBuffer, 100))
 {  
  char *Item = new char[20];
  strcpy(Item, "Hello World!");
  Buffer.push(Item);
  ReleaseMutex(m_hMutexBuffer);
  printf("0x%08x/n", Item);
  printf("0x%08x/n", &Item);
  SetEvent(m_hEventBuffer);  
  Sleep(10);
 } 
 return 0;
}

DWORD WINAPI ThreadRead(LPVOID lParam)
{
 if (WAIT_OBJECT_0 ==WaitForSingleObject(m_hEventBuffer, INFINITE))
 {
  if (WAIT_OBJECT_0 == WaitForSingleObject(m_hMutexBuffer, 100))
  {
   char * _Item = Buffer.front();
   Buffer.pop();
   if (Buffer.empty())
   {
    ResetEvent(m_hEventBuffer);
   }
   ReleaseMutex(m_hMutexBuffer);

   printf("%s/n", _Item);

   printf("0x%08x/n", _Item);
   printf("0x%08x/n", &_Item);

   Sleep(10);
   
   delete []  _Item;

   _Item = NULL;
  }
 } 
 return 0;
}

 

在终端打印如下：

0x00372d68

0x0051ffb0

Hello World!

0x00372d68

0x0061ffb0

可见写线程中的Item与读线程_Item地址不同，在各自的栈空间上分配，相差0x00100000大小的地址空间，而Item与_Item指向相同的内存空间，这个内存空间是在进程的全局堆空间上分配的。

delete 函数只能调用一次，因为Item 和 _Item是在栈上分配的，在线程中由系统自己回收，但二者指向相同的内存空间，因此只能释放一次。利用这个特性，我们可以很方便地在线程间离开内存通信，并可以很好地解决分配与回收的问题。