/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/multithread/ThreadGroup.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 "ThreadGroup.hpp"


using namespace Millie;

void ThreadGroup::init()
{
  _isRunning = false;
  _isStarted = false;
  _nbwaitingthread = 0;


  pthread_mutex_init(&_mutexWaitAll, 0);
  pthread_cond_init(&_waitSynchro, 0);
}

ThreadGroup::ThreadGroup()
{
  init();
}

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

bool ThreadGroup::isStarted()
{
  MutexLock mlock(_synchronizedIsStarted);
  return _isStarted;
}

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

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


void ThreadGroup::joinAll()
{

  if(isStarted())
  {
    for(unsigned int i = 0; i< _vectThread.size(); i++)
    {
      _vectThread[i]->join();
    }

    MutexLock plock(_synchronizedIsRunning);
    _isRunning = false;
  }
}

unsigned int ThreadGroup::getNbGThread()
{
  MutexLock mlock(_synchronizedNbThread);

  return(_vectThread.size());
}

int ThreadGroup::getNbWaitingGThread()
{
  MutexLock mlock(_synchronizedWaitingThread);
  return _nbwaitingthread;
}

bool ThreadGroup::threadWaitAll(GThread * t, pthread_mutex_t ** mutex, pthread_cond_t ** wait)
{

  if(!isStarted())
  {
    throw IllegalThreadStateException("ThreadWaitAll : group is not started");
  }

  MutexLock mlock(_synchronizedWaitingThread);

  MutexLock plock(_synchronizedNbThread);

  pthread_mutex_lock(&_mutexWaitAll);

  bool b = false;

  for(unsigned int i = 0; i<_vectThread.size(); i++)
  {
    if(_vectThread[i]== t && !(_vectWaiting[i]==true) )
    {
      b = true;
      _vectWaiting[i] = true; //maintenant il va attendre
      break;
    }
  }

  if(b==false)
  {
    pthread_mutex_unlock(&_mutexWaitAll);
    throw RuntimeThreadException("Thread doesn't exist");
  }

  *mutex = &_mutexWaitAll;
  *wait = &_waitSynchro;


  if(_nbwaitingthread == _vectThread.size()-1)
  {
    for(unsigned int i = 0; i<_vectThread.size(); i++)
      _vectWaiting[i] = false;

    _nbwaitingthread = 0;


    pthread_cond_broadcast(&_waitSynchro);

    pthread_mutex_unlock(&_mutexWaitAll);

    return false;
  }
  else
  {
    _nbwaitingthread++;
    return true;
  }
}

void ThreadGroup::notifyAll()
{
  if(!isStarted())
    throw IllegalThreadStateException("ThreadGroup::notifyAll : is not started");

  for(unsigned int i = 0; i<_vectThread.size();i++)
  {
    _vectThread[i]->notify();
    _vectWaiting[i] = false;
  }
  _nbwaitingthread = 0;
}

void ThreadGroup::startAll()
{

  MutexLock nbthread(_synchronizedNbThread);
  MutexLock startAll(_synchronizedIsStarted);
  MutexLock isRunning(_synchronizedIsRunning);

  _isStarted = true;
  _isRunning = true;
  for(unsigned int i = 0; i< _vectThread.size(); i++)
  {
    std::cerr<<"Start thread "<<i<<std::endl;
    _vectThread[i]->start();
  }
}

void ThreadGroup::add(GThread * thread)
{
  MutexLock started(_synchronizedIsStarted);

  if(_isStarted)
  {
    delete thread;
    throw IllegalThreadStateException("ThreadGroup : add");
  }

  thread->setGroup(this);



  MutexLock mlock(_synchronizedNbThread);

  for(unsigned int i = 0; i<_vectThread.size(); i++)
    if(thread == _vectThread[i])
    {
      throw IllegalArgument("ThreadGroup : thread still add");
    }

  _vectThread.push_back(thread);
  _vectWaiting.push_back(false);

}

ThreadGroup::~ThreadGroup()
{
  joinAll();

  pthread_mutex_destroy(&_mutexWaitAll);


  pthread_cond_destroy(&_waitSynchro);

  for(unsigned int i =0; i< _vectThread.size(); i++)
  {
    delete _vectThread[i];
    _vectThread[i] = 0;
  }
  _vectThread.clear();
  _vectWaiting.clear();
}


GThread & ThreadGroup::operator[](unsigned int pos)
{
  MutexLock mlock(_synchronizedNbThread);

  if(pos < _vectThread.size())
    return *_vectThread[pos];
  else
    throw OutOfRange("ThreadGroup::operator[] : bad access");
}

---