[pthread] fails to create new thread even after old ones have terminated

Hi,
I have recently being learning and experimenting with pthread, and have noticed a weird behaviour (to me). I wrote a simple testing program to show my question:

Code:

---

#include <pthread.h>
#include <iostream>

void *doNothing(void *);

int main () {
        pthread_t nothingThread;
        int count = 0;
        while (!(pthread_create(&nothingThread, NULL, doNothing, NULL))) {
                count++;
                usleep(1000); //so threads won't be created faster than they are terminated
        }
        std::cout << count << std::endl;
}

void *doNothing(void *) {
        pthread_exit(NULL);
}

---

the program, when run, terminates almost immediately, printing "382" on my Linux machine, apparently after hitting some limit. I expected it to run indefinitely because every thread created terminates itself. Can someone please enlighten me on this question?

Thank you very much

ps. a variation of this test program -

Code:

---

#include <pthread.h>
#include <iostream>

void *doNothing(void *);

int main () {
        pthread_t nothingThread;
        int count = 0;
        while (!(pthread_create(&nothingThread, NULL, doNothing, NULL))) {
                pthread_cancel(nothingThread);
                count++;
                usleep(1000);
        }
        std::cout << count << std::endl;
}

void *doNothing(void *) {
        for (;;);
}

---

gives the same result;

I think I found the solution to this problem.

For a thread to clean up after itself, it has to be detached (as opposed to being joinable).

eg.

Code:

---

#include <pthread.h>
#include <iostream>

void *doNothing(void *);

int main () {
        pthread_t nothingThread;
        int count = 0;
        while (!(pthread_create(&nothingThread, NULL, doNothing, NULL))) {
                pthread_detach(nothingThread);
                count++;
                usleep(1000);
        }
        std::cout << count << std::endl;
}

void *doNothing(void *) {
        pthread_exit(NULL);
}

---

1. pthread_cancel does only work on special "cancellation points" (google will tell you what count as them)
2. imo you have to call pthread_join after pthread_cancel to be sure it is canceled afterwards

if you do not need true async thread cancellation I would suggest to signal a thread to end itself as often as possible. So you don't have to mess with thread properties, cancellation points and cleanup

thank you for your reply, google did lead me to this answer

Quote:

---

imo you have to call pthread_join after pthread_cancel to be sure it is canceled afterwards

---

if a thread is detached, calling any pthread_* function "on" it is undefined. For detached threads, the best solution I found is to set a flag in a global variable immediately before it exits to signal other threads.

Quote:

---

if you do not need true async thread cancellation I would suggest to signal a thread to end itself as often as possible. So you don't have to mess with thread properties, cancellation points and cleanup

---

hmm.. I don't quite understand that. I thought async cancellation gives no regard to cancellation points and cancel immediately?

Quote:

---

Originally Posted by cyberfish

hmm.. I don't quite understand that. I thought async cancellation gives no regard to cancellation points and cancel immediately?

---

I found it easier (probably to a lack of knowledge, I couldn't get pthread_cancel to work under win32 and boost::threads have no cancel function at all) to let the thread end itself if I tell him to:

Code:

---

bool endThread = false;

// create thread

// run main program

// end thread before exiting

// lock
endThread = true;
// unlock
// join thread

void* thread_fun(void*)
{
  // lock
  cpy_endThread =  endThread;
  // unlock

  while(!cpy_endThread)
  {
      // thread work

      //    lock
      cpy_endThread =  endThread;
      // unlock
  }
}

---

I can get pthread_cancel() to work under win32 like this:

Code:

---


// create thread

// run main program

// end thread before exiting

// pthread cancel

// pthread join

void* thread_fun(void*)
{

  while(true)
  {
      // thread work
      pthread_testcancel(); //set a cancellation point
  }
}

---

I see, testcancel seems to be the missing part for me. But because I want to migrate to boost threads some day I let it the way it's done for now.

I just took a look at Boost threads and it looks very promising to me. Maybe I will switch too =)

I was surprised that there isn't a function to cancel a thread though, seems important to me.

Of course we can implement thread cancelling ourselves like you have done, but I would rather prefer a simpler and less error-prone solution.

[edit]
according to boost thread FAQ (http://www.boost.org/doc/html/thread/faq.html),

Quote:

---

9. Why isn't thread cancellation or termination provided?

There's a valid need for thread termination, so at some point Boost.Thread probably will include it, but only after we can find a truly safe (and portable) mechanism for this concept.

---

seems like we will just have to wait.
[/edit]

the boost people say, as a response to many requests, that cancel will come, if a proper solution is found. they seem to say it for a good while now :)