Help, how to design a pool of executors

classic Classic list List threaded Threaded
2 messages Options
Reply | Threaded
Open this post in threaded view
|

Help, how to design a pool of executors

Andrej Navodnik
Hello all,

I would kindly ask someone for a gentle hand to guide
me through the
problems related to the concurrent programming.

My problem is the following. I'd like to design a
special structure/pool of
executors which gives a priority to the task that
testing element satisfies
a special intermediate condition. If an algorithm
could verify that the
testing element is appropriate for further use then
the task that has
found this element is allowed to cancel all other
tasks in pool and calculate
the final result based on this "optimal element".

Let's say that I have a set of elements from which I
want to find  an optimal
element. During testing whether an element is
appropriate or not an element must
satisfy some kind of an intermediate condition. If an
intermediate condition is
not satisfied then the pool select another element for
testing. If this
intermediate condition is satisfied then the task that
has found this element:
  - is allowed to cancel all other tasks in the pool;
  - is allowed to disable that the pool could to
accept new elements for testing;
  - is the only one that is allowed to continue and
calculate the final result.
Structure should either return null (there are no
elements that could satisfy
an intermediate condition) or final result based on
input "optimal element".

The behavior of the tasks in the pool could be
explained with the following
picture:

0----5------x
 1-----7----x
  2---6-----x
   3-----9-!-------------->
    4---8---x

Legend:
0, 1, 2, 3, 4: ... finished tasks/elements which could
not satisfy
                   intermediate condition;
5, 7, 6, 8: ...... canceled tasks by task testing
element number 9;
9: ............... task that has found that an element
that satisfies intermediate
                   condition, has canceled all other
currently running tasks
                   in the pool and is allowed to
calculate the final result;
!: ............... time when the task has found out
that the element number 9
                   satisfies an intermediate
condition; from that time on the task
                   with element number 9 is the only
one executing in the pool;

Is it wise to design such kind of structure? I'm
prepared to do some homework
but I don't know where to start (which objects to put
together). Is it possible
that the costs using this kind of structure could be
higher than the benefits?
I'm aware of the examples in class
ExecutorCompletionService but are not
behaving the way I want.

Best regards,
Andrei



       
               
__________________________________
Yahoo! Mail - PC Magazine Editors' Choice 2005
http://mail.yahoo.com
_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest
Reply | Threaded
Open this post in threaded view
|

Re: Help, how to design a pool of executors

Joe Bowbeer
I believe the cancellation mechanism you desire can be implemented by
hooking the done() method of FutureTask.

For some executor service,

ExecutorService service = Executors.newFixedThreadPool(n);

You can create and execute your tasks roughly as follows:

Runnable task = new FutureTask(callable) {
  protected void done() {
    try {
      System.out.println("Answer is " + get());
      // succeeded - shutdown service
      service.shutdownNow();
    } catch (Exception ex) { }
  }
};

service.execute(task);


Note that in our terminology, a ThreadPool executor maintains a "pool"
of threads and a queue of tasks.


On 11/3/05, Andrej Navodnik <[hidden email]> wrote:

> Hello all,
>
> I would kindly ask someone for a gentle hand to guide
> me through the
> problems related to the concurrent programming.
>
> My problem is the following. I'd like to design a
> special structure/pool of
> executors which gives a priority to the task that
> testing element satisfies
> a special intermediate condition. If an algorithm
> could verify that the
> testing element is appropriate for further use then
> the task that has
> found this element is allowed to cancel all other
> tasks in pool and calculate
> the final result based on this "optimal element".
>
> Let's say that I have a set of elements from which I
> want to find  an optimal
> element. During testing whether an element is
> appropriate or not an element must
> satisfy some kind of an intermediate condition. If an
> intermediate condition is
> not satisfied then the pool select another element for
> testing. If this
> intermediate condition is satisfied then the task that
> has found this element:
>   - is allowed to cancel all other tasks in the pool;
>   - is allowed to disable that the pool could to
> accept new elements for testing;
>   - is the only one that is allowed to continue and
> calculate the final result.
> Structure should either return null (there are no
> elements that could satisfy
> an intermediate condition) or final result based on
> input "optimal element".
>
> The behavior of the tasks in the pool could be
> explained with the following
> picture:
>
> 0----5------x
>  1-----7----x
>   2---6-----x
>    3-----9-!-------------->
>     4---8---x
>
> Legend:
> 0, 1, 2, 3, 4: ... finished tasks/elements which could
> not satisfy
>                    intermediate condition;
> 5, 7, 6, 8: ...... canceled tasks by task testing
> element number 9;
> 9: ............... task that has found that an element
> that satisfies intermediate
>                    condition, has canceled all other
> currently running tasks
>                    in the pool and is allowed to
> calculate the final result;
> !: ............... time when the task has found out
> that the element number 9
>                    satisfies an intermediate
> condition; from that time on the task
>                    with element number 9 is the only
> one executing in the pool;
>
> Is it wise to design such kind of structure? I'm
> prepared to do some homework
> but I don't know where to start (which objects to put
> together). Is it possible
> that the costs using this kind of structure could be
> higher than the benefits?
> I'm aware of the examples in class
> ExecutorCompletionService but are not
> behaving the way I want.
>
> Best regards,
> Andrei
>

_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest