include/amino/exec_serv.h

Go to the documentation of this file.

/*
 * (c) Copyright 2008, IBM Corporation.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *  Change History:
 *
 *  yy-mm-dd  Developer  Defect     Description
 *  --------  ---------  ------     -----------
 *  08-08-04  ganzhi     N/A        Initial version
 */
#ifndef AMINO_UTIL_EXECUTOR_SERVICE
#define AMINO_UTIL_EXECUTOR_SERVICE

#include <pthread.h>
#include <string>
#include <stdio.h>
#include <time.h>
#include <cassert>

#include <amino/thread.h>
#include <amino/condition.h>
#include <amino/mutex.h>
#include <amino/lock.h>
#include <amino/cstdatomic>

namespace amino{

    class ExecutorService{
        protected:
            volatile bool fShutdown;
            condition_variable condFinish;
            recursive_mutex f_mutex_finish;
            void notify_finish(){
                unique_lock<recursive_mutex> llock(f_mutex_finish);
                condFinish.notify_all();
            }
        public:
            virtual void shutdown()=0;

            virtual void halt()=0;

            virtual bool finished()=0;

            virtual void waitTermination(){
#ifdef DEBUG
                cout<<"Begin WaitTermination of ExecutorService\n";
#endif
                if(!fShutdown)
                    throw std::logic_error(
                            "Call shutdown()/halt() before wait "
                            "termination of this executor!\n");

                unique_lock<recursive_mutex> llock(f_mutex_finish);

                while(!finished())
                    condFinish.wait(llock);

#ifdef DEBUG
                assert(finished());
                cout<<"Finish WaitTermination\n";
#endif
                return;
            }

            virtual bool waitTermination(int timeOut){
                if(!fShutdown)
                    throw std::logic_error(
                            "Call shutdown()/halt() before wait "
                            "termination of this executor!\n");

                unique_lock<recursive_mutex> llock(f_mutex_finish);
                if(!finished()){
                    condFinish.timed_wait(llock, timeOut);

                    return finished();
                }

                return finished();
            }
    };
}
#endif

---