issue #14

* new thread_group class to handle abstract_threads
* new abstract_thread (probably safer).

Author: HerbertKoelman

cpp-pthread.xcodeproj/project.pbxproj

@@ -286,7 +286,10 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(SRCROOT)/include";
+				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)/include",
+					"$(SRCROOT)/../include",
+				);
 				MACOSX_DEPLOYMENT_TARGET = 10.11;
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -325,7 +328,10 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(SRCROOT)/include";
+				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)/include",
+					"$(SRCROOT)/../include",
+				);
 				MACOSX_DEPLOYMENT_TARGET = 10.11;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = macosx;
@@ -369,6 +375,7 @@
 				E5B044101CAE7342005C89BB /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
 		};
 		E5EC5B6C1C9C2C3000E21131 /* Build configuration list for PBXProject "cpp-pthread" */ = {
 			isa = XCConfigurationList;

include/ibm.hpp

@@ -13,6 +13,7 @@
 #include <string>
 #include <functional>
 #include <memory>
+#include <list>
 
 #include "pthread/config.h"
 
@@ -151,6 +152,52 @@ namespace pthread {
     thread_status  _status;
   };
 
+  class abstract_thread: public runnable {
+  public:
+    virtual ~abstract_thread();
+    
+    void start();
+    
+    int join() { return _thread->join() ;};
+    
+  private:
+    pthread::thread *_thread;
+  };
+  
+  /** group (list) of abstract_threads.
+   *
+   * method in this class apply's to all threads in the group. this means that when an thread_group instance is deallocated, all threads it references are deleted.
+   */
+  class thread_group{
+  public:
+    /** Setup a thread container/list.
+     *
+     * @param destructor_joins_first if true then destructor tries to join all regsitered threads before deleting thread instances.
+     */
+    thread_group( bool destructor_joins_first = false ) __NOEXCEPT__;
+    
+    /** delete all threads referenced by the thread_group.
+     */
+    virtual ~thread_group();
+    
+    /** @param add/register a thread to the group.
+     */
+    void add(abstract_thread *thread);
+    
+    /** start run all registered threads.
+     * @see add(abstract_thread *thread)
+     */
+    void start();
+    
+    /** what for all threads to join the caller of this method.
+     */
+    void join();
+    
+  private:
+    std::list<pthread::abstract_thread*> _threads;
+    bool                                 _destructor_joins_first;
+  };
+  
   // exception & errors --------
 
   class thread_exception: public pthread_exception {

include/pthread/thread.hpp

@@ -55,19 +55,11 @@ namespace pthread {
     return rc;
   }
 
-#ifdef __IBMCPP__
   thread::thread(): _status(thread_status::not_a_thread), _thread(0){
-#else
-  thread::thread(): _status{thread_status::not_a_thread}, _thread{nullptr}{
-#endif
 
   }
 
-#ifdef __IBMCPP__
   thread::thread (const runnable &work): thread(){
-#else
-  thread::thread (const runnable &work): thread{}{
-#endif
     int rc = 0 ;
     pthread_attr_t attr;
 
@@ -109,9 +101,50 @@ namespace pthread {
   }
 
   thread::~thread () {
-//    if ( _status == thread_status::a_thread ){
-//      pthread_attr_destroy(&_attr);
-//    }
+  }
+  
+  abstract_thread::~abstract_thread(){
+  
+    delete _thread;
+  }
+  
+  void abstract_thread::start(){
+    
+    _thread = new pthread::thread(*this);
+  }
+  
+  thread_group::thread_group(bool destructor_joins_first ) __NOEXCEPT__: _destructor_joins_first(destructor_joins_first){
+    
+  }
+  
+  thread_group::~thread_group(){
+    while(! _threads.empty()){
+      std::auto_ptr<pthread::abstract_thread> pat(_threads.front());
+      _threads.pop_front();
+      
+      if ( _destructor_joins_first ){
+        try {
+          pat->join();
+        } catch ( ... ){};
+      }
+    }
+  }
+  
+  void thread_group::add(pthread::abstract_thread *thread){
+    
+    _threads.push_back(thread);
+  }
+  
+  void thread_group::start(){
+      for(auto iterator = _threads.begin(); iterator != _threads.end(); iterator++){
+        (*iterator)->start();
+      }
+  }
+  
+  void thread_group::join(){
+    for(auto iterator = _threads.begin(); iterator != _threads.end(); iterator++){
+      (*iterator)->join();
+    }
   }
 
   /**
@@ -128,11 +161,7 @@ namespace pthread {
 
   // exception -------
 
-#ifdef __IBMCPP__
   thread_exception::thread_exception(const string message, const int pthread_error): pthread_exception(message, pthread_error){
-#else
-  thread_exception::thread_exception(const string message, const int pthread_error): pthread_exception{message, pthread_error}{
-#endif
   }
 
 } // namespace pthread

src/thread.cpp

@@ -25,7 +25,7 @@ void message ( const std::string m){
   std::cout << m << std::endl;
 }
 
-class worker: public pthread::runnable {
+class worker: public pthread::abstract_thread {
 public:
 
   worker(const std::string m = "anonymous worker", int sleep = 2*1000): msg(m), _sleep(sleep){
@@ -37,7 +37,7 @@ class worker: public pthread::runnable {
   };
 
   void run() __NOEXCEPT__ __OVERRIDE__ {
-    
+    message("worker: " + msg);
     {
       pthread::lock_guard<pthread::mutex> lck(mtx);
 
@@ -67,40 +67,37 @@ class worker: public pthread::runnable {
 int main(int argc, const char * argv[]) {
 
   pthread::string dummy;
-  worker w("laura");
-  pthread::thread t0;
-  pthread::thread t2(w);
-  t0 = ibm::move(t2) ;
-  t0.join();
 
-  std::auto_ptr<pthread::thread> pt0(new pthread::thread(w));
-  pt0->join();
-
-//  std::list<std::auto_ptr<pthread::thread>> threads;
-  std::list<pthread::thread> threads;
-  for (auto x = 20 ; x > 0 ; x--){
-//    threads.push_back(std::auto_ptr<pthread::thread>(new pthread::thread(w)));
-    threads.push_back(ibm::move(pthread::thread(w)));
+  {
+    worker w1("herbert", 2);
+    w1.start();
+    w1.join();
   }
-//  threads.push_back(pthread::thread(w));
-//  threads.push_back(pthread::thread(w));
-//  threads.push_back(pthread::thread(w));
-//  threads.push_back(pthread::thread(worker("herbert's worker")));
+//  worker w("laura");
+//  pthread::thread t0;
+//  pthread::thread t2(w);
+//  t0 = ibm::move(t2) ;
+//  t0.join();
 //  
-//  message("increment counter");
-//  for ( auto x = 20000 ; x > 0 ; x--){
-//    pthread::lock_guard<pthread::mutex> lck(mtx);
-//    counter++ ;
-//    condition.notify_one();
-//  }
-//  message("main is waiting for threads to finish");
-//  
-//  std::list<std::auto_ptr<pthread::thread>>::iterator iterator;
-//  for(iterator = threads.begin(); iterator != threads.end(); iterator++){
-//    message("join a thread (loop)");
-//    (*iterator)->join();
-//  }
+//  std::auto_ptr<pthread::thread> pt0(new pthread::thread(worker("laura")));
+//  pt0->join();
 
+  pthread::thread_group threads(true);
+  for (auto x = 10 ; x > 0 ; x--){
+    threads.add( new worker("herbert"));
+  }
+  
+  threads.start();
+  
+  message("main increment counter");
+  for ( auto x = 20000 ; x > 0 ; x--){
+    pthread::lock_guard<pthread::mutex> lck(mtx);
+    counter++ ;
+  }
+  condition.notify_all();
+  
+//  message("main is waiting for threads to finish");
+//  threads.join();
   message( "end reached");
 
 }