Memory Leak While using ACE_Thread

[Kachin]

I have a situation where I have to scan some FTP Servers every 5 seconds to check for some specific files and download them if they exist. I use a Shell script to do FTP download operation and call it using C++ system call in a separate thread. (I am on Linux)
Here is how the code skeleton looks like:

//Main thread
handle_timeout //called every 5 seconds
{
HandleFTPOper();
}

HandleFTPOper()
{
//Allocate memory in heap here
FTPLoginDetails pFTPLogin = new FTPLoginDetails();

//fill the allocated memory (FTPLoginDetails) here
....

//Create a child thread and pass the FTP Login details to the thread as input argument
ACE_Thread::spawn((ACE_THR_FUNC)&Download, pFTPLogin);

//return to main thread, no need to join/wait for the created thread.
return;
}

//child thread
static void* Download(FTPLoginDetails *pData)
{
//Pass the FTP Login Details to shell script which will download some files
system("Download.sh -a arguments");

//delete the input data
delete [] pData;
return 0;
}

This code is working but it is leading to a memory leak. (the main process restarts after about an hour (i.e. after calling the download function around 720 times) owing to lack of memory for other variables in the system. I tried to reason as follows:

1) The pData is not being deleted somehow and getting leaked.
But this was not the case. I removed the pData heap allocation and declared it as a (stack) variable inside the child-thread, hard coded the log in details. But, there was still a memory leak.

2) The created threads are not getting destroyed.
This is the most likely possibility. Note that I deliberately left out any join or wait condition in the main thread as I do not want the main thread to wait for the child thread's FTP Operation to complete.

To sum up, I am creating a new thread every 5 seconds and leaving them on their own to do the FTP Operation and wind up. I don't bother to wait in the main thread after creating them and go on doing my things. I know it doesn't sound like a good design, but I am working on a very restrictive base code.

Now, the reason for memory leak could be because of the created child threads not destroyed.
But am I assuming anything wrong here? Isn't a ACE thread supposed to destory itself and free its resources when it "falls through" the function? What could be the problem?

[hoxsiew]

I don't know about ACE threads, but I know that pthreads created with a default attribute structure (by passing NULL to pthread_create's second parameter) will result in a zombie thread when the thread is finished. You need to initialize a pthread_attr_t structure and specify a detached thread using pthread_attr_setdetachedstate with PTHREAD_CREATE_DETACHED.

Perhaps ACE threads have a similar default an need to be initialized as pthreads.

[Kachin]

Thanks hoxsiew. It was the problem of zombie threads as you said. ACE threads, creates joinable threads by default and it led to the problem. I searched and found the thr_detachable alternative for ACE. Thanks again.