16 #ifndef HAZELCAST_CLIENT_IEXECUTORSERVICE_H_ 17 #define HAZELCAST_CLIENT_IEXECUTORSERVICE_H_ 21 #include "hazelcast/util/HazelcastDll.h" 22 #include "hazelcast/client/cluster/memberselector/MemberSelectors.h" 23 #include "hazelcast/client/ICompletableFuture.h" 24 #include "hazelcast/client/proxy/ProxyImpl.h" 25 #include "hazelcast/client/ExecutionCallback.h" 26 #include "hazelcast/client/MultiExecutionCallback.h" 27 #include "hazelcast/client/Member.h" 28 #include "hazelcast/client/spi/ClientClusterService.h" 29 #include "hazelcast/client/spi/ClientContext.h" 30 #include "hazelcast/util/UuidUtil.h" 31 #include "hazelcast/client/spi/impl/ClientInvocation.h" 32 #include "hazelcast/util/ExceptionUtil.h" 33 #include "hazelcast/client/spi/impl/ClientExecutionServiceImpl.h" 34 #include "hazelcast/client/internal/executor/CompletedFuture.h" 35 #include "hazelcast/client/proxy/IExecutorDelegatingFuture.h" 38 #include "hazelcast/client/protocol/codec/ExecutorServiceSubmitToPartitionCodec.h" 39 #include "hazelcast/client/protocol/codec/ExecutorServiceSubmitToAddressCodec.h" 41 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) 43 #pragma warning(disable: 4251) //for dll export 50 class ExecutorServiceProxyFactory;
65 friend class executor::impl::ExecutorServiceProxyFactory;
68 static const std::string SERVICE_NAME;
79 template<
typename HazelcastSerializable>
80 void execute(
const HazelcastSerializable &command) {
81 submit<HazelcastSerializable, bool>(command);
91 template<
typename HazelcastSerializable>
92 void execute(
const HazelcastSerializable &command,
94 std::vector<Member> members = selectMembers(memberSelector);
95 int selectedMember = rand() % (int) members.size();
96 executeOnMember<HazelcastSerializable>(command, members[selectedMember]);
105 template<
typename HazelcastSerializable,
typename K>
107 submitToKeyOwner<HazelcastSerializable, K>(command, key);
116 template<
typename HazelcastSerializable>
118 submitToMember<HazelcastSerializable, bool>(command, member);
127 template<
typename HazelcastSerializable>
128 void executeOnMembers(
const HazelcastSerializable &command,
const std::vector<Member> &members) {
129 for (std::vector<Member>::const_iterator it = members.begin(); it != members.end(); ++it) {
130 submitToMember<HazelcastSerializable, bool>(command, *it);
141 template<
typename HazelcastSerializable>
144 std::vector<Member> members = selectMembers(memberSelector);
145 executeOnMembers<HazelcastSerializable>(command, members);
153 template<
typename HazelcastSerializable>
155 std::vector<Member> memberList = getContext().getClientClusterService().getMemberList();
156 for (std::vector<Member>::const_iterator it = memberList.begin(); it != memberList.end(); ++it) {
157 submitToMember<HazelcastSerializable, bool>(command, *it);
170 template<
typename HazelcastSerializable,
typename T,
typename K>
171 boost::shared_ptr<ICompletableFuture<T> >
173 return submitToKeyOwnerInternal<HazelcastSerializable, T, K>(task, key, boost::shared_ptr<T>(),
false);
185 template<
typename HazelcastSerializable,
typename T>
186 boost::shared_ptr<ICompletableFuture<T> >
188 const Address memberAddress = getMemberAddress(member);
189 return submitToTargetInternal<HazelcastSerializable, T>(task, memberAddress, boost::shared_ptr<T>(),
202 template<
typename HazelcastSerializable,
typename T>
203 std::map<Member, boost::shared_ptr<ICompletableFuture<T> > >
204 submitToMembers(
const HazelcastSerializable &task,
const std::vector<Member> &members) {
205 std::map<Member, boost::shared_ptr<ICompletableFuture<T> > > futureMap;
206 for (std::vector<Member>::const_iterator it = members.begin(); it != members.end(); ++it) {
207 Address memberAddress = getMemberAddress(*it);
208 boost::shared_ptr<ICompletableFuture<T> > f = submitToTargetInternal<HazelcastSerializable, T>(task,
210 boost::shared_ptr<T>(),
227 template<
typename HazelcastSerializable,
typename T>
228 std::map<Member, boost::shared_ptr<ICompletableFuture<T> > >
231 std::vector<Member> members = selectMembers(memberSelector);
232 return submitToMembers<HazelcastSerializable, T>(task, members);
243 template<
typename HazelcastSerializable,
typename T>
244 std::map<Member, boost::shared_ptr<ICompletableFuture<T> > >
246 std::vector<Member> members = getContext().getClientClusterService().getMemberList();
247 std::map<Member, boost::shared_ptr<ICompletableFuture<T> > > futureMap;
248 for (std::vector<Member>::const_iterator it = members.begin(); it != members.end(); ++it) {
249 Address memberAddress = getMemberAddress(*it);
250 boost::shared_ptr<ICompletableFuture<T> > f = submitToTargetInternal<HazelcastSerializable, T>(task,
252 boost::shared_ptr<T>(),
272 template<
typename HazelcastSerializable,
typename T>
273 boost::shared_ptr<ICompletableFuture<T> >
274 submit(
const HazelcastSerializable &task,
const boost::shared_ptr<T> &result) {
275 Data taskData = toData<HazelcastSerializable>(task);
277 if (taskData.hasPartitionHash()) {
278 int partitionId = getPartitionId(taskData);
280 return submitToPartitionInternal<T>(taskData, result,
false, partitionId);
282 return submitToRandomInternal<T>(taskData, result,
false);
304 template<
typename HazelcastSerializable,
typename T>
305 boost::shared_ptr<ICompletableFuture<T> >
submit(
const HazelcastSerializable &task) {
306 return submit<HazelcastSerializable, T>(task, boost::shared_ptr<T>());
317 template<
typename HazelcastSerializable,
typename T>
319 Data taskData = toData<HazelcastSerializable>(task);
321 if (taskData.hasPartitionHash()) {
322 int partitionId = getPartitionId(taskData);
324 submitToPartitionInternal<T>(taskData, partitionId, callback);
326 submitToRandomInternal<T>(taskData, callback);
340 template<
typename HazelcastSerializable,
typename T>
341 boost::shared_ptr<ICompletableFuture<T> >
343 std::vector<Member> members = selectMembers(memberSelector);
344 int selectedMember = rand() % (int) members.size();
345 return submitToMember<HazelcastSerializable, T>(task, members[selectedMember]);
358 template<
typename HazelcastSerializable,
typename T>
362 std::vector<Member> members = selectMembers(memberSelector);
363 int selectedMember = rand() % (int) members.size();
364 return submitToMember(task, members[selectedMember], callback);
376 template<
typename HazelcastSerializable,
typename T,
typename K>
379 submitToKeyOwnerInternal<HazelcastSerializable, T, K>(task, key, callback);
391 template<
typename HazelcastSerializable,
typename T>
394 const Address memberAddress = getMemberAddress(member);
395 return submitToTargetInternal<HazelcastSerializable, T>(task, memberAddress, callback);
407 template<
typename HazelcastSerializable,
typename T>
408 void submitToMembers(
const HazelcastSerializable &task,
const std::vector<Member> &members,
410 boost::shared_ptr<MultiExecutionCallbackWrapper < T> >
411 multiExecutionCallbackWrapper(
new MultiExecutionCallbackWrapper<T>((
int) members.size(), callback));
413 for (std::vector<Member>::const_iterator it = members.begin(); it != members.end(); ++it) {
414 boost::shared_ptr<ExecutionCallbackWrapper < T> >
415 executionCallback(
new ExecutionCallbackWrapper<T>(multiExecutionCallbackWrapper, *it));
416 submitToMember<HazelcastSerializable, T>(task, *it, executionCallback);
430 template<
typename HazelcastSerializable,
typename T>
434 std::vector<Member> members = selectMembers(memberSelector);
435 submitToMembers<HazelcastSerializable, T>(task, members, callback);
446 template<
typename HazelcastSerializable,
typename T>
449 std::vector<Member> memberList = getContext().getClientClusterService().getMemberList();
450 submitToMembers<HazelcastSerializable, T>(task, memberList, callback);
451 boost::shared_ptr<MultiExecutionCallbackWrapper < T> >
452 multiExecutionCallbackWrapper(
new MultiExecutionCallbackWrapper<T>((
int) memberList.size(), callback));
453 for (std::vector<Member>::const_iterator it = memberList.begin(); it != memberList.end(); ++it) {
454 boost::shared_ptr<ExecutionCallbackWrapper < T> >
455 executionCallback(
new ExecutionCallbackWrapper<T>(multiExecutionCallbackWrapper, *it));
456 submitToMember<HazelcastSerializable, T>(task, *it, executionCallback);
493 MultiExecutionCallbackWrapper(
495 : multiExecutionCallback(multiExecutionCallback), members(memberSize) {
499 virtual void onResponse(
const Member &member,
const boost::shared_ptr<T> &value) {
500 multiExecutionCallback->onResponse(member, value);
501 values.put(member, value);
503 int waitingResponse = --members;
504 if (waitingResponse == 0) {
510 onFailure(
const Member &member,
const boost::shared_ptr<exception::IException> &exception) {
511 multiExecutionCallback->onFailure(member, exception);
512 exceptions.put(member, exception);
514 int waitingResponse = --members;
515 if (waitingResponse == 0) {
520 virtual void onComplete(
const std::map<
Member, boost::shared_ptr<T> > &values,
521 const std::map<
Member, boost::shared_ptr<exception::IException> > &exceptions) {
522 multiExecutionCallback->onComplete(values, exceptions);
527 std::map<Member, boost::shared_ptr<T> > completedValues;
528 typedef std::vector<std::pair<Member, boost::shared_ptr<T> > > ENTRYVECTOR;
529 ENTRYVECTOR entries = values.entrySet();
530 for (
typename ENTRYVECTOR::const_iterator it = entries.begin();
531 it != entries.end(); ++it) {
532 completedValues[it->first] = it->second;
535 std::map<Member, boost::shared_ptr<exception::IException> > completedExceptions;
536 typedef std::vector<std::pair<Member, boost::shared_ptr<exception::IException> > > EXCEPTIONVECTOR;
537 EXCEPTIONVECTOR exceptionEntries = exceptions.entrySet();
538 for (
typename EXCEPTIONVECTOR::const_iterator it = exceptionEntries.begin();
539 it != exceptionEntries.end(); ++it) {
540 completedExceptions[it->first] = it->second;
543 onComplete(completedValues, completedExceptions);
546 const boost::shared_ptr<MultiExecutionCallback<T> > multiExecutionCallback;
547 util::SynchronizedMap<Member, T> values;
548 util::SynchronizedMap<Member, exception::IException> exceptions;
549 util::AtomicInt members;
555 ExecutionCallbackWrapper(
556 const boost::shared_ptr<MultiExecutionCallbackWrapper<T> > &multiExecutionCallbackWrapper,
557 const Member &member) : multiExecutionCallbackWrapper(multiExecutionCallbackWrapper),
560 virtual void onResponse(
const boost::shared_ptr<T> &response) {
561 multiExecutionCallbackWrapper->onResponse(member, response);
564 virtual void onFailure(
const boost::shared_ptr<exception::IException> &e) {
565 multiExecutionCallbackWrapper->onFailure(member, e);
569 const boost::shared_ptr<MultiExecutionCallbackWrapper<T> > multiExecutionCallbackWrapper;
576 boost::shared_ptr<ICompletableFuture<T> >
577 submitToPartitionInternal(
const serialization::pimpl::Data &taskData,
578 const boost::shared_ptr<T> &defaultValue,
579 bool preventSync,
int partitionId) {
580 std::string uuid = util::UuidUtil::newUnsecureUuidString();
582 boost::shared_ptr<spi::impl::ClientInvocationFuture> f = invokeOnPartitionInternal(taskData,
585 return checkSync(f, uuid, partitionId, preventSync, defaultValue);
589 void submitToPartitionInternal(
const serialization::pimpl::Data &taskData,
int partitionId,
591 std::string uuid = util::UuidUtil::newUnsecureUuidString();
593 boost::shared_ptr<spi::impl::ClientInvocationFuture> f = invokeOnPartitionInternal(taskData,
597 boost::shared_ptr<ICompletableFuture<T> > delegatingFuture(
599 SUBMIT_TO_PARTITION_DECODER<T>(),
600 boost::shared_ptr<T>()));
602 delegatingFuture->andThen(callback);
605 boost::shared_ptr<spi::impl::ClientInvocationFuture>
606 invokeOnPartitionInternal(
const Data &taskData,
int partitionId,
const std::string &uuid) {
607 std::auto_ptr<protocol::ClientMessage> request =
608 protocol::codec::ExecutorServiceSubmitToPartitionCodec::encodeRequest(name, uuid, taskData,
611 return invokeOnPartitionOwner(request, partitionId);
614 template<
typename HazelcastSerializable,
typename T,
typename K>
615 boost::shared_ptr<ICompletableFuture<T> >
616 submitToKeyOwnerInternal(
const HazelcastSerializable &task,
const K &key,
617 const boost::shared_ptr<T> &defaultValue,
bool preventSync) {
619 Data dataKey = toData<K>(key);
621 int partitionId = getPartitionId(dataKey);
623 return submitToPartitionInternal<T>(toData<HazelcastSerializable>(task), defaultValue, preventSync,
627 template<
typename HazelcastSerializable,
typename T,
typename K>
628 void submitToKeyOwnerInternal(
const HazelcastSerializable &task,
const K &key,
631 Data dataKey = toData<K>(key);
633 int partitionId = getPartitionId(dataKey);
635 submitToPartitionInternal<T>(toData<HazelcastSerializable>(task), partitionId, callback);
639 boost::shared_ptr<ICompletableFuture<T> >
640 submitToRandomInternal(
const serialization::pimpl::Data &taskData,
const boost::shared_ptr<T> &defaultValue,
643 int partitionId = randomPartitionId();
645 return submitToPartitionInternal<T>(taskData, defaultValue, preventSync, partitionId);
649 void submitToRandomInternal(
const serialization::pimpl::Data &taskData,
652 int partitionId = randomPartitionId();
654 submitToPartitionInternal<T>(taskData, partitionId, callback);
657 template<
typename HazelcastSerializable,
typename T>
658 boost::shared_ptr<ICompletableFuture<T> >
659 submitToTargetInternal(
const HazelcastSerializable &task,
const Address &address,
660 const boost::shared_ptr<T> &defaultValue,
bool preventSync) {
661 std::string uuid = util::UuidUtil::newUnsecureUuidString();
663 boost::shared_ptr<spi::impl::ClientInvocationFuture> f = invokeOnAddressInternal<HazelcastSerializable>(
664 task, address, uuid);
666 return checkSync<T>(f, uuid, address, preventSync, defaultValue);
669 template<
typename HazelcastSerializable,
typename T>
670 void submitToTargetInternal(
const HazelcastSerializable &task,
const Address &address,
672 std::string uuid = util::UuidUtil::newUnsecureUuidString();
674 boost::shared_ptr<spi::impl::ClientInvocationFuture> f = invokeOnAddressInternal<HazelcastSerializable>(
675 task, address, uuid);
677 boost::shared_ptr<ICompletableFuture<T> > delegatingFuture(
679 SUBMIT_TO_ADDRESS_DECODER<T>(),
680 boost::shared_ptr<T>()));
682 delegatingFuture->andThen(callback);
685 template<
typename HazelcastSerializable>
686 boost::shared_ptr<spi::impl::ClientInvocationFuture>
687 invokeOnAddressInternal(
const HazelcastSerializable &task,
const Address &address,
688 const std::string &uuid) {
689 std::auto_ptr<protocol::ClientMessage> request =
690 protocol::codec::ExecutorServiceSubmitToAddressCodec::encodeRequest(name, uuid,
694 boost::shared_ptr<spi::impl::ClientInvocationFuture> f = invokeOnTarget(request, address);
698 boost::shared_ptr<spi::impl::ClientInvocationFuture>
699 invokeOnPartitionOwner(std::auto_ptr<protocol::ClientMessage> &request,
int partitionId);
701 boost::shared_ptr<spi::impl::ClientInvocationFuture>
702 invokeOnTarget(std::auto_ptr<protocol::ClientMessage> &request,
const Address &target);
706 retrieveResultFromMessage(
const boost::shared_ptr<spi::impl::ClientInvocationFuture> &f) {
707 serialization::pimpl::SerializationService &serializationService = getContext().getSerializationService();
708 std::auto_ptr<serialization::pimpl::Data> data = protocol::codec::ExecutorServiceSubmitToAddressCodec::ResponseParameters::decode(
710 return boost::shared_ptr<T>(serializationService.toObject<T>(data.get()));
714 boost::shared_ptr<ICompletableFuture<T> >
715 checkSync(
const boost::shared_ptr<spi::impl::ClientInvocationFuture> &f,
const std::string &uuid,
716 int partitionId,
bool preventSync, boost::shared_ptr<T> defaultValue) {
717 bool sync = isSyncComputation(preventSync);
719 return retrieveResultSync<T>(f);
721 return boost::shared_ptr<ICompletableFuture<T> >(
722 new proxy::IExecutorDelegatingFuture<T>(f, getContext(), uuid, defaultValue,
723 SUBMIT_TO_PARTITION_DECODER<T>(), name,
730 boost::shared_ptr<ICompletableFuture<T> >
731 checkSync(
const boost::shared_ptr<spi::impl::ClientInvocationFuture> &f,
const std::string &uuid,
732 const Address &address,
bool preventSync, boost::shared_ptr<T> defaultValue) {
733 bool sync = isSyncComputation(preventSync);
735 return retrieveResultSync<T>(f);
737 return boost::shared_ptr<ICompletableFuture<T> >(
738 new proxy::IExecutorDelegatingFuture<T>(f, getContext(), uuid, defaultValue,
739 SUBMIT_TO_ADDRESS_DECODER<T>(), name, address));
745 boost::shared_ptr<ICompletableFuture<T> >
746 retrieveResultSync(
const boost::shared_ptr<spi::impl::ClientInvocationFuture> &f) {
748 boost::shared_ptr<T> response = retrieveResultFromMessage<T>(f);
749 boost::shared_ptr<ExecutorService> userExecutor = getContext().getClientExecutionService().getUserExecutor();
750 return boost::shared_ptr<ICompletableFuture<T> >(
751 new internal::executor::CompletedFuture<T>(response, userExecutor));
753 boost::shared_ptr<ExecutorService> userExecutor = getContext().getClientExecutionService().getUserExecutor();
754 return boost::shared_ptr<ICompletableFuture<T> >(
755 new internal::executor::CompletedFuture<T>(
756 boost::shared_ptr<exception::IException>(e.
clone()), userExecutor));
760 bool isSyncComputation(
bool preventSync);
764 int randomPartitionId();
767 static const boost::shared_ptr<impl::ClientMessageDecoder<T> > SUBMIT_TO_PARTITION_DECODER() {
768 return impl::DataMessageDecoder<protocol::codec::ExecutorServiceSubmitToPartitionCodec, T>::instance();
772 static const boost::shared_ptr<impl::ClientMessageDecoder<T> > SUBMIT_TO_ADDRESS_DECODER() {
773 return impl::DataMessageDecoder<protocol::codec::ExecutorServiceSubmitToAddressCodec, T>::instance();
776 static const int32_t MIN_TIME_RESOLUTION_OF_CONSECUTIVE_SUBMITS = 10;
777 static const int32_t MAX_CONSECUTIVE_SUBMITS = 100;
779 util::Atomic<int32_t> consecutiveSubmits;
780 util::Atomic<int64_t> lastSubmitTime;
785 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) void submit(const HazelcastSerializable &task, const cluster::memberselector::MemberSelector &memberSelector, const boost::shared_ptr< ExecutionCallback< T > > &callback)
Submits a task to randomly selected members.
Definition: IExecutorService.h:360
void execute(const HazelcastSerializable &command, const cluster::memberselector::MemberSelector &memberSelector)
Executes a task on a randomly selected member.
Definition: IExecutorService.h:92
boost::shared_ptr< ICompletableFuture< T > > submit(const HazelcastSerializable &task)
Submits a value-returning task for execution and returns a ICompletableFuture representing the pendin...
Definition: IExecutorService.h:305
boost::shared_ptr< ICompletableFuture< T > > submitToKeyOwner(const HazelcastSerializable &task, const K &key)
Submits a task to the owner of the specified key and returns a ICompletableFuture representing that t...
Definition: IExecutorService.h:172
The Client Delegating Future is used to delegate ClientInvocationFuture to a user type to be used wit...
Definition: ClientDelegatingFuture.h:40
Base class for all exception originated from Hazelcast methods.
Definition: IException.h:53
void executeOnMembers(const HazelcastSerializable &command, const std::vector< Member > &members)
Executes a task on each of the specified members.
Definition: IExecutorService.h:128
void executeOnKeyOwner(const HazelcastSerializable &command, const K &key)
Executes a task on the owner of the specified key.
Definition: IExecutorService.h:106
void submitToMembers(const HazelcastSerializable &task, const std::vector< Member > &members, const boost::shared_ptr< MultiExecutionCallback< T > > &callback)
Submits a task to the specified members.
Definition: IExecutorService.h:408
boost::shared_ptr< ICompletableFuture< T > > submit(const HazelcastSerializable &task, const cluster::memberselector::MemberSelector &memberSelector)
Submits a task to a randomly selected member and returns a ICompletableFuture representing that task...
Definition: IExecutorService.h:342
void submitToMember(const HazelcastSerializable &task, const Member &member, const boost::shared_ptr< ExecutionCallback< T > > &callback)
Submits a task to the specified member.
Definition: IExecutorService.h:392
void executeOnAllMembers(const HazelcastSerializable &command)
Executes a task on all of the known cluster members.
Definition: IExecutorService.h:154
IP Address.
Definition: Address.h:41
void submit(const HazelcastSerializable &task, const boost::shared_ptr< ExecutionCallback< T > > &callback)
Submits a task to a random member.
Definition: IExecutorService.h:318
boost::shared_ptr< ICompletableFuture< T > > submit(const HazelcastSerializable &task, const boost::shared_ptr< T > &result)
Submits a task for execution and returns a ICompletableFuture representing that task.
Definition: IExecutorService.h:274
std::map< Member, boost::shared_ptr< ICompletableFuture< T > > > submitToMembers(const HazelcastSerializable &task, const cluster::memberselector::MemberSelector &memberSelector)
Submits a task to selected members and returns a map of Member-ICompletableFuture pairs representing ...
Definition: IExecutorService.h:229
void submitToMembers(const HazelcastSerializable &task, const cluster::memberselector::MemberSelector &memberSelector, const boost::shared_ptr< MultiExecutionCallback< T > > &callback)
Submits task to the selected members.
Definition: IExecutorService.h:431
Definition: MemberSelectors.h:46
void executeOnMembers(const HazelcastSerializable &command, const cluster::memberselector::MemberSelector &memberSelector)
Executes a task on each of the selected members.
Definition: IExecutorService.h:142
void submitToAllMembers(const HazelcastSerializable &task, const boost::shared_ptr< MultiExecutionCallback< T > > &callback)
Submits task to all the cluster members.
Definition: IExecutorService.h:447
virtual std::auto_ptr< IException > clone() const
We need this method to clone the specific derived exception when needed.
Definition: IException.cpp:91
void execute(const HazelcastSerializable &command)
Executes the given command at some time in the future.
Definition: IExecutorService.h:80
void executeOnMember(const HazelcastSerializable &command, const Member &member)
Executes a task on the specified member.
Definition: IExecutorService.h:117
Cluster member class.
Definition: Member.h:43
std::map< Member, boost::shared_ptr< ICompletableFuture< T > > > submitToMembers(const HazelcastSerializable &task, const std::vector< Member > &members)
Submits a task to given members and returns map of Member-ICompletableFuture pairs representing pendi...
Definition: IExecutorService.h:204
std::map< Member, boost::shared_ptr< ICompletableFuture< T > > > submitToAllMembers(const HazelcastSerializable &task)
Submits task to all cluster members and returns a map of Member-ICompletableFuture pairs representing...
Definition: IExecutorService.h:245
PN (Positive-Negative) CRDT counter.
Definition: MapEntryView.h:32
void submitToKeyOwner(const HazelcastSerializable &task, const K &key, const boost::shared_ptr< ExecutionCallback< T > > &callback)
Submits a task to the owner of the specified key.
Definition: IExecutorService.h:377
boost::shared_ptr< ICompletableFuture< T > > submitToMember(const HazelcastSerializable &task, const Member &member)
Submits a task to the specified member and returns a ICompletableFuture representing that task...
Definition: IExecutorService.h:187
Distributed implementation of java.util.concurrent.ExecutorService.
Definition: IExecutorService.h:64