If you can read this text, it means you are not experiencing this website at its best. This website is designed for used with a standards-compliant browser.
Current version: 2.3.2
ZThreads
A platform-independent, multi-threading and synchronization library for C++
Home Documentation Downloads CVS Contact
ConcurrentExecutor Class Reference

#include <ConcurrentExecutor.h>

Inheritance diagram for ConcurrentExecutor:
Executor Cancelable Waitable NonCopyable

Public Member Functions

 ConcurrentExecutor ()
 Create a ConcurrentExecutor.
 
virtual void interrupt ()
 
virtual void execute (const Task &)
 
virtual void cancel ()
 
virtual bool isCanceled ()
 
virtual void wait ()
 
virtual bool wait (unsigned long timeout)
 
virtual void interrupt ()=0
 
virtual void execute (const Task &task)=0
 
- Public Member Functions inherited from Cancelable
virtual ~Cancelable ()
 Destroy a Cancelable object.
 
virtual void cancel ()=0
 
virtual bool isCanceled ()=0
 
- Public Member Functions inherited from Waitable
virtual ~Waitable ()
 Destroy a Waitable object.

 
virtual void wait ()=0
 
virtual bool wait (unsigned long timeout)=0
 

Detailed Description

Author
Eric Crahen http://www.code-foo.com
Date
<2003-07-16T22:36:11-0400>
Version
2.3.0

A ConcurrentExecutor spawns a single thread to service a series of Tasks.

See also
PoolExecutor.

Member Function Documentation

◆ cancel()

virtual void cancel ( )
virtual
See also
Cancelable::cancel()

Implements Cancelable.

◆ execute()

virtual void execute ( const Task )
virtual

Submit a Task to this Executor. This will not block the current thread for very long. The task will be enqueued internally and eventually run in the context of the single thread driving all the Tasks submitted to this Executor.

Exceptions
Cancellation_Exceptionthrown if this Executor has been canceled. The Task being submitted will not be executed by this Executor.
Synchronization_Exceptionthrown only in the event of an error in the implementation of the library.
See also
Executor::execute(const Task&)

Implements Executor.

◆ interrupt()

virtual void interrupt ( )
virtual

Interrupting a ConcurrentExecutor will cause the thread running the tasks to be be interrupted once during the execution of each task that has been submitted at the time this function is called.

Tasks that are submitted after this function is called will not be interrupt()ed; unless this function is invoked again().

void aFunction() {
// Submit p Tasks
for(size_t n = 0; n < p; n++)
executor.execute(new aRunnable);
// Tasks [m, p) may be interrupted, where m is the first task that has
// not completed at the time the interrupt() is invoked.
executor.interrupt();
// Submit (q - p) Tasks
for(size_t n = p; n < q; n++)
executor.execute(new Chore);
// Tasks [p, q) are not interrupted
}
ConcurrentExecutor()
Create a ConcurrentExecutor.

Implements Executor.

◆ isCanceled()

virtual bool isCanceled ( )
virtual
See also
Cancelable::isCanceled()

Implements Cancelable.

◆ wait() [1/2]

virtual void wait ( )
virtual
See also
PoolExecutor::wait()

Implements Waitable.

◆ wait() [2/2]

virtual bool wait ( unsigned long  timeout)
virtual

The documentation for this class was generated from the following file: