/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/multithread/Thread.cpp

Aller à la documentation de ce fichier.

/******************************************************************************
 *       __    _    _   _       _       _   _____                             *
 *       | \  / |  | | | |     | |     | |  | ___|                            *
 *       |  \/  |  | | | |     | |     | |  | |_                              *
 *       |      |  | | | |     | |     | |  |  _|                             *
 *       | |\/| |  | | | |__   | |__   | |  | |__                             *
 *       |_|  |_|  |_| |____|  |____|  |_|  |____|                            *
 * __________________________________________________________________________ *
 *                 Multifunctional Library For Image Processing               *
 *                                                                            *
 *                                                                            *
 *                                                                            *
 *      (c) Copyright 2007 by Humbert Florent                                 *
 *                                                                            *
 *      This program is free software; you can redistribute it and/or modify  *
 *      it under the terms of the GNU General Public License as published by  *
 *      the Free Software Foundation; only version 2 of the License.          *
 *                                                                            *
 *      This program is distributed in the hope that it will be useful,       *
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *      GNU General Public License for more details.                          *
 *                                                                            *
 *      You should have received a copy of the GNU General Public License     *
 *      along with this program; if not, write to the Free Software           *
 *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA             *
 *      02111-1307, USA.                                                      *
 ******************************************************************************/


#include "Thread.hpp"


using namespace Millie;

void * Millie::threadHandler(void * pthread)
{
  Thread * current = static_cast<Thread*>(pthread);
  MutexLock mlock(current->_synchronizedRun);
  try
  {
    current->run();
  }
  catch(std::exception& e)
  {
    std::cerr<<e.what()<<std::endl;
  }
  catch(...)
  {
    std::cerr<<"Failure"<<std::endl;
  }

  MutexLock plock(current->_synchronizedIsAlive);
  current->_isAlive = false;
  return NULL;
}

void Thread::init()
{
  _isAlive = true;
  _isStarted = false;
  _wasJoined = false;
  pthread_cond_init(&_waitSynchro, 0);


  pthread_mutex_init(&_waitMutex, 0);
  pthread_mutex_init(&_mutexWaitAll, 0);

}

Thread::Thread()
{
  init();
}

Thread::Thread(const std::string & name)
{
  init();
  _name = name;
}

Thread::~Thread()
{
  /*on ne rejoint pas et on prefère lancer une exception
   * qui montre une erreur de programmation.
   * De plus, il y a des problèmes  si les classes qui héritent
   * sont détruites juste avant ~Thread(), les données pourraient être
   * incohérente.
   */
  //join();
  MutexLock lock(_synchronizedStart)
  ;

  pthread_cond_destroy(&_waitSynchro);

  pthread_mutex_destroy(&_waitMutex);
  pthread_mutex_destroy(&_mutexWaitAll);


  _isAlive = false;
  _isStarted = false;

  if(!_wasJoined)
    throw IllegalThreadStateException("Thread was not joined");
}

bool Thread::isRunning()
{
  MutexLock mlock(_synchronizedIsRunning);
  return _isRunning;
}



void Thread::wait()
{
  Mutex mlock(_synchronizedIsRunning);
  if(!_isRunning)
    throw IllegalThreadStateException("Thread : wait");

  pthread_mutex_lock(&_waitMutex);
  pthread_cond_wait(&_waitSynchro, &_waitMutex);
  pthread_mutex_unlock(&_waitMutex);
}

void Thread::notify()
{
  pthread_mutex_lock(&_waitMutex);
  pthread_cond_broadcast(&_waitSynchro);
  pthread_mutex_unlock(&_waitMutex);
}


bool Thread::isAlive()
{
  MutexLock mlock(_synchronizedIsAlive);
  return _isAlive;
}

void Thread::start()
{
  MutexLock mstart(_synchronizedStart);

  if(_isStarted)
    throw IllegalThreadStateException("Thread : still started");

  _isStarted = true;

  MutexLock mlock(_synchronizedRun);
  MutexLock plock(_synchronizedIsRunning);


  _isRunning = true;

  if(pthread_create(&_thread, NULL, threadHandler, this)!=0)
  {
    _isRunning = false;
    throw ThreadCreationFailed("Start : creation failed");
  }

}

void Thread::join()
{
  MutexLock lock(_synchronizedStart)
  ;
  if(_isStarted && !_wasJoined)
    pthread_join(_thread, NULL);

  _wasJoined = true;
  /*sinon, il n'a jamais été lancé, on ne l'attend pas*/
}

ThreadID Thread::currentThread()
{
  return static_cast<ThreadID>(pthread_self());
}


const std::string & Thread::getName() const
{
  return _name;
}


ThreadID Thread::getThreadId() const
{
  return static_cast<ThreadID>(_thread);
}

---