Многопоточные приложения

#include <iostream>
#include <fstream>
#include <pthread.h>
 
/***************************************************************************/
 
struct mutex {
   mutex() { pthread_mutex_init(&m, NULL); }
   ~mutex() { pthread_mutex_destroy(&m); }
 
   void lock() { pthread_mutex_lock(&m); }
   void unlock() { pthread_mutex_unlock(&m); }
private:
   pthread_mutex_t m;
};
 
struct mutex_locker {
   mutex_locker(mutex& m_):m(m_) { m.lock(); }
   ~mutex_locker() { m.unlock(); }
private:
   mutex& m;
};
 
struct thread_args {
   thread_args(std::ostream& f_, mutex& m_, int c_)
      :file(f_),m(m_),c(c_)
   {}
   /**  */
   std::ostream& file;
   mutex& m;
   int c;
};
 
void* thread_func(void* p) {
   thread_args* args = reinterpret_cast<thread_args*>(p);
   for ( int i = 0; i < args->c; ++i ) {
      mutex_locker locker(args->m);
      args->file << pthread_self() << std::endl;
   }
   return NULL;
}
 
/***************************************************************************/
 
int main(int argv, const char** argc) {
   std::ofstream file("file.txt", std::ios::out|std::ios::trunc);
   if ( !file ) {
      std::cerr << "can`t create file!" << std::endl;
      return 1;
   }
   const int thcount = 3;
   const int cycles = 1000;
   mutex m;
   pthread_t threads[thcount] = {0};
   thread_args args(file, m, cycles);
 
   pthread_create(&threads[0], NULL, thread_func, (void*)&args);
   pthread_create(&threads[1], NULL, thread_func, (void*)&args);
   pthread_create(&threads[2], NULL, thread_func, (void*)&args);
 
   std::cout << "starting " << thcount << " threads\nwaiting for finish..." << std::endl;
 
   pthread_join(threads[0], NULL);
   pthread_join(threads[1], NULL);
   pthread_join(threads[2], NULL);
 
   std::cout << "all threads are finished" << std::endl;
   return 0;
}
 
/***************************************************************************/

args->file << (size_t)pthread_self() << std::endl;

args->file << (size_t)[U]pthread_self[/U]() << std::endl;