<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<link rel="canonical" href="https://ignite.apache.org/releases/2.0.0/javadoc/org/apache/ignite/IgniteCompute.html" />
<META NAME="ROBOTS" CONTENT="NOINDEX">

<!-- Generated by javadoc (version 1.7.0_80) on Sun Apr 30 12:27:10 MSK 2017 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>IgniteCompute (Ignite 2.0.0)</title>
<meta name="date" content="2017-04-30">
<link rel="stylesheet" type="text/css" href="../../../javadoc.css" title="Style">

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-61232409-1', 'auto');
  ga('send', 'pageview');

</script></head>
<body>
<script type="text/javascript"><!--
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="IgniteCompute (Ignite 2.0.0)";
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!--   -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/IgniteCompute.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../index-all.html">Index</a></li>
<li><a href="../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em>Ignite - In-Memory Data Fabric</em></div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../org/apache/ignite/IgniteCluster.html" title="interface in org.apache.ignite"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../org/apache/ignite/IgniteCondition.html" title="interface in org.apache.ignite"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?org/apache/ignite/IgniteCompute.html" target="_top">Frames</a></li>
<li><a href="IgniteCompute.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.ignite</div>
<h2 title="Interface IgniteCompute" class="title">Interface IgniteCompute</h2>
</div>
<div class="contentContainer">
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Superinterfaces:</dt>
<dd><a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html" title="interface in org.apache.ignite.lang">IgniteAsyncSupport</a></dd>
</dl>
<hr>
<br>
<pre>public interface <span class="strong">IgniteCompute</span>
extends <a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html" title="interface in org.apache.ignite.lang">IgniteAsyncSupport</a></pre>
<div class="block">Defines compute grid functionality for executing tasks and closures over nodes
 in the <a href="../../../org/apache/ignite/cluster/ClusterGroup.html" title="interface in org.apache.ignite.cluster"><code>ClusterGroup</code></a>. Instance of <code>IgniteCompute</code> is obtained from <a href="../../../org/apache/ignite/Ignite.html" title="interface in org.apache.ignite"><code>Ignite</code></a>
 as follows:
 <pre name="code" class="java">
 Ignite ignite = Ignition.ignite();

 // Compute over all nodes in the cluster.
 IgniteCompute c = ignite.compute();
 </pre>
 You can also get an instance of <a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite"><code>IgniteCompute</code></a> over a subset of cluster nodes, i.e. over
 a <a href="../../../org/apache/ignite/cluster/ClusterGroup.html" title="interface in org.apache.ignite.cluster"><code>ClusterGroup</code></a>:
 <pre name="code" class="java">
 // Cluster group composed of all remote nodes.
 ClusterGroup rmtGrp = ignite.cluster().forRemotes();

 // Compute over remote nodes only.
 IgniteCompute c = ignite.compute(rmtGrp);
 </pre>
 The methods are grouped as follows:
 <ul>
 <li><code>apply(...)</code> methods execute <a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang"><code>IgniteClosure</code></a> jobs over nodes in the cluster group.</li>
 <li><code>call(...)</code> methods execute <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang"><code>IgniteCallable</code></a> jobs over nodes in the cluster group.</li>
 <li><code>run(...)</code> methods execute <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang"><code>IgniteRunnable</code></a> jobs over nodes in the cluster group.</li>
 <li><code>broadcast(...)</code> methods broadcast jobs to all nodes in the cluster group.</li>
 <li><code>affinityCall(...)</code> and <code>affinityRun(...)</code> methods collocate jobs with nodes
  on which a specified key is cached.</li>
 </ul>
 Note that if attempt is made to execute a computation over an empty cluster group (i.e. cluster group
 that does not have any alive nodes), then <a href="../../../org/apache/ignite/cluster/ClusterGroupEmptyException.html" title="class in org.apache.ignite.cluster"><code>ClusterGroupEmptyException</code></a>
 will be thrown out of result future.
 <h1 class="header">Load Balancing</h1>
 In all cases other than <code>broadcast(...)</code>, Ignite must select a node for a computation
 to be executed. The node will be selected based on the underlying <a href="../../../org/apache/ignite/spi/loadbalancing/LoadBalancingSpi.html" title="interface in org.apache.ignite.spi.loadbalancing"><code>LoadBalancingSpi</code></a>,
 which by default sequentially picks next available node from the underlying cluster group. Other
 load balancing policies, such as <code>random</code> or <code>adaptive</code>, can be configured as well by
 selecting a different load balancing SPI in Ignite configuration. If your logic requires some custom
 load balancing behavior, consider implementing <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> directly.
 <h1 class="header">Fault Tolerance</h1>
 Ignite guarantees that as long as there is at least one grid node standing, every job will be
 executed. Jobs will automatically failover to another node if a remote node crashed
 or has rejected execution due to lack of resources. By default, in case of failover, next
 load balanced node will be picked for job execution. Also jobs will never be re-routed to the
 nodes they have failed on. This behavior can be changed by configuring any of the existing or a custom
 <a href="../../../org/apache/ignite/spi/failover/FailoverSpi.html" title="interface in org.apache.ignite.spi.failover"><code>FailoverSpi</code></a> in grid configuration.
 <h1 class="header">Resource Injection</h1>
 All compute jobs, including closures, runnables, callables, and tasks can be injected with
 ignite resources. Both, field and method based injections are supported. The following grid
 resources can be injected:
 <ul>
 <li><a href="../../../org/apache/ignite/resources/TaskSessionResource.html" title="annotation in org.apache.ignite.resources"><code>TaskSessionResource</code></a></li>
 <li><a href="../../../org/apache/ignite/resources/IgniteInstanceResource.html" title="annotation in org.apache.ignite.resources"><code>IgniteInstanceResource</code></a></li>
 <li><a href="../../../org/apache/ignite/resources/LoggerResource.html" title="annotation in org.apache.ignite.resources"><code>LoggerResource</code></a></li>
 <li><a href="../../../org/apache/ignite/resources/SpringApplicationContextResource.html" title="annotation in org.apache.ignite.resources"><code>SpringApplicationContextResource</code></a></li>
 <li><a href="../../../org/apache/ignite/resources/SpringResource.html" title="annotation in org.apache.ignite.resources"><code>SpringResource</code></a></li>
 </ul>
 Refer to corresponding resource documentation for more information.
 Here is an example of how to inject instance of <a href="../../../org/apache/ignite/Ignite.html" title="interface in org.apache.ignite"><code>Ignite</code></a> into a computation:
 <pre name="code" class="java">
 public class MyIgniteJob extends IgniteRunnable {
      ...
      &#64;IgniteInstanceResource
      private Ignite ignite;
      ...
  }
 </pre>
 <h1 class="header">Computation SPIs</h1>
 Note that regardless of which method is used for executing computations, all relevant SPI implementations
 configured for this compute instance will be used (i.e. failover, load balancing, collision resolution,
 checkpoints, etc.). If you need to override configured defaults, you should use compute task together with
 <a href="../../../org/apache/ignite/compute/ComputeTaskSpis.html" title="annotation in org.apache.ignite.compute"><code>ComputeTaskSpis</code></a> annotation. Refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation for more information.</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="../../../org/apache/ignite/lang/IgniteUuid.html" title="class in org.apache.ignite.lang">IgniteUuid</a>,<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#activeTaskFutures()">activeTaskFutures</a></strong>()</code>
<div class="block">Gets tasks future for active tasks started on local node.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityCall(java.util.Collection,%20int,%20org.apache.ignite.lang.IgniteCallable)">affinityCall</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
            int&nbsp;partId,
            <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes given job on the node where partition is located (the partition is primary on the node)
 
 It's guaranteed that the data of all the partitions of all participating caches,
 the affinity key belongs to, will present on the destination node throughout the job execution.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityCall(java.util.Collection,%20java.lang.Object,%20org.apache.ignite.lang.IgniteCallable)">affinityCall</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
            <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
            <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityCall(java.lang.String,%20java.lang.Object,%20org.apache.ignite.lang.IgniteCallable)">affinityCall</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
            <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
            <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityCallAsync(java.util.Collection,%20int,%20org.apache.ignite.lang.IgniteCallable)">affinityCallAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                 int&nbsp;partId,
                 <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes given job asynchronously on the node where partition is located (the partition is primary on the node)
 The data of the partition will not be migrated from the target node
 while the job is executed.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityCallAsync(java.util.Collection,%20java.lang.Object,%20org.apache.ignite.lang.IgniteCallable)">affinityCallAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                 <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                 <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityCallAsync(java.lang.String,%20java.lang.Object,%20org.apache.ignite.lang.IgniteCallable)">affinityCallAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
                 <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                 <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityRun(java.util.Collection,%20int,%20org.apache.ignite.lang.IgniteRunnable)">affinityRun</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
           int&nbsp;partId,
           <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes given job on the node where partition is located (the partition is primary on the node)
 
 It's guaranteed that the data of all the partitions of all participating caches,
 the affinity key belongs to, will present on the destination node throughout the job execution.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityRun(java.util.Collection,%20java.lang.Object,%20org.apache.ignite.lang.IgniteRunnable)">affinityRun</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
           <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
           <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityRun(java.lang.String,%20java.lang.Object,%20org.apache.ignite.lang.IgniteRunnable)">affinityRun</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
           <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
           <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityRunAsync(java.util.Collection,%20int,%20org.apache.ignite.lang.IgniteRunnable)">affinityRunAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                int&nbsp;partId,
                <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes given job asynchronously on the node where partition is located (the partition is primary on the node)
 The data of the partition will not be migrated from the target node
 while the job is executed.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityRunAsync(java.util.Collection,%20java.lang.Object,%20org.apache.ignite.lang.IgniteRunnable)">affinityRunAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#affinityRunAsync(java.lang.String,%20java.lang.Object,%20org.apache.ignite.lang.IgniteRunnable)">affinityRunAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
                <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#apply(org.apache.ignite.lang.IgniteClosure,%20java.util.Collection)">apply</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
     <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args)</code>
<div class="block">Executes provided closure job on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R,T&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#apply(org.apache.ignite.lang.IgniteClosure,%20T)">apply</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
     T&nbsp;arg)</code>
<div class="block">Executes provided closure job on a node within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R1,R2,T&gt;&nbsp;R2</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#apply(org.apache.ignite.lang.IgniteClosure,%20java.util.Collection,%20org.apache.ignite.lang.IgniteReducer)">apply</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R1&gt;&nbsp;job,
     <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args,
     <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)</code>
<div class="block">Executes provided closure job on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#applyAsync(org.apache.ignite.lang.IgniteClosure,%20java.util.Collection)">applyAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
          <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args)</code>
<div class="block">Executes provided closure job asynchronously on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R,T&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#applyAsync(org.apache.ignite.lang.IgniteClosure,%20T)">applyAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
          T&nbsp;arg)</code>
<div class="block">Executes provided closure job asynchronously on a node within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R1,R2,T&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R2&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#applyAsync(org.apache.ignite.lang.IgniteClosure,%20java.util.Collection,%20org.apache.ignite.lang.IgniteReducer)">applyAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R1&gt;&nbsp;job,
          <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args,
          <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)</code>
<div class="block">Executes provided closure job asynchronously on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#broadcast(org.apache.ignite.lang.IgniteCallable)">broadcast</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Broadcasts given job to all nodes in cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R,T&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#broadcast(org.apache.ignite.lang.IgniteClosure,%20T)">broadcast</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
         T&nbsp;arg)</code>
<div class="block">Broadcasts given closure job with passed in argument to all nodes in the cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#broadcast(org.apache.ignite.lang.IgniteRunnable)">broadcast</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Broadcasts given job to all nodes in the cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#broadcastAsync(org.apache.ignite.lang.IgniteCallable)">broadcastAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Broadcasts given job asynchronously to all nodes in cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R,T&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#broadcastAsync(org.apache.ignite.lang.IgniteClosure,%20T)">broadcastAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
              T&nbsp;arg)</code>
<div class="block">Broadcasts given closure job asynchronously with passed in argument to all nodes in the cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#broadcastAsync(org.apache.ignite.lang.IgniteRunnable)">broadcastAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Broadcasts given job asynchronously to all nodes in the cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#call(java.util.Collection)">call</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&gt;&nbsp;jobs)</code>
<div class="block">Executes collection of jobs on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R1,R2&gt;&nbsp;R2</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#call(java.util.Collection,%20org.apache.ignite.lang.IgniteReducer)">call</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R1&gt;&gt;&nbsp;jobs,
    <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)</code>
<div class="block">Executes collection of jobs on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#call(org.apache.ignite.lang.IgniteCallable)">call</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes provided job on a node within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#callAsync(java.util.Collection)">callAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&gt;&nbsp;jobs)</code>
<div class="block">Executes collection of jobs asynchronously on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;R1,R2&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R2&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#callAsync(java.util.Collection,%20org.apache.ignite.lang.IgniteReducer)">callAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R1&gt;&gt;&nbsp;jobs,
         <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)</code>
<div class="block">Executes collection of jobs asynchronously on nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#callAsync(org.apache.ignite.lang.IgniteCallable)">callAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)</code>
<div class="block">Executes provided job asynchronously on a node within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/cluster/ClusterGroup.html" title="interface in org.apache.ignite.cluster">ClusterGroup</a></code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#clusterGroup()">clusterGroup</a></strong>()</code>
<div class="block">Gets cluster group to which this <code>IgniteCompute</code> instance belongs.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#execute(java.lang.Class,%20T)">execute</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&gt;&nbsp;taskCls,
       T&nbsp;arg)</code>
<div class="block">Executes given task on within the cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#execute(org.apache.ignite.compute.ComputeTask,%20T)">execute</a></strong>(<a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&nbsp;task,
       T&nbsp;arg)</code>
<div class="block">Executes given task within the cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;R</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#execute(java.lang.String,%20T)">execute</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName,
       T&nbsp;arg)</code>
<div class="block">Executes given task within the cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#executeAsync(java.lang.Class,%20T)">executeAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&gt;&nbsp;taskCls,
            T&nbsp;arg)</code>
<div class="block">Executes given task asynchronously on within the cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#executeAsync(org.apache.ignite.compute.ComputeTask,%20T)">executeAsync</a></strong>(<a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&nbsp;task,
            T&nbsp;arg)</code>
<div class="block">Executes given task asynchronously within the cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#executeAsync(java.lang.String,%20T)">executeAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName,
            T&nbsp;arg)</code>
<div class="block">Executes given task asynchronously within the cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#future()">future</a></strong>()</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#localDeployTask(java.lang.Class,%20java.lang.ClassLoader)">localDeployTask</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&gt;&nbsp;taskCls,
               <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;clsLdr)</code>
<div class="block">Explicitly deploys a task with given class loader on the local node.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="http://docs.oracle.com/javase/7/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;?,?&gt;&gt;&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#localTasks()">localTasks</a></strong>()</code>
<div class="block">Gets map of all locally deployed tasks keyed by their task name .</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#run(java.util.Collection)">run</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&gt;&nbsp;jobs)</code>
<div class="block">Executes collection of jobs on grid nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#run(org.apache.ignite.lang.IgniteRunnable)">run</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes provided job on a node within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#runAsync(java.util.Collection)">runAsync</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&gt;&nbsp;jobs)</code>
<div class="block">Executes collection of jobs asynchronously on grid nodes within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#runAsync(org.apache.ignite.lang.IgniteRunnable)">runAsync</a></strong>(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)</code>
<div class="block">Executes provided job asynchronously on a node within the underlying cluster group.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#undeployTask(java.lang.String)">undeployTask</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName)</code>
<div class="block">Makes the best attempt to undeploy a task with given name within the underlying cluster group.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a></code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#withAsync()">withAsync</a></strong>()</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a></code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#withExecutor(java.lang.String)">withExecutor</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Gets instance of the compute API associated with custom executor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a></code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#withName(java.lang.String)">withName</a></strong>(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName)</code>
<div class="block">Sets task name for the next executed task in the <b>current thread</b>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a></code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#withNoFailover()">withNoFailover</a></strong>()</code>
<div class="block">Sets no-failover flag for the next task executed in the <b>current thread</b>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a></code></td>
<td class="colLast"><code><strong><a href="../../../org/apache/ignite/IgniteCompute.html#withTimeout(long)">withTimeout</a></strong>(long&nbsp;timeout)</code>
<div class="block">Sets task timeout for the next executed task in the <b>current thread</b>.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_org.apache.ignite.lang.IgniteAsyncSupport">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;org.apache.ignite.lang.<a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html" title="interface in org.apache.ignite.lang">IgniteAsyncSupport</a></h3>
<code><a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html#isAsync()">isAsync</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method_detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="clusterGroup()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clusterGroup</h4>
<pre><a href="../../../org/apache/ignite/cluster/ClusterGroup.html" title="interface in org.apache.ignite.cluster">ClusterGroup</a>&nbsp;clusterGroup()</pre>
<div class="block">Gets cluster group to which this <code>IgniteCompute</code> instance belongs.</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>Cluster group to which this <code>IgniteCompute</code> instance belongs.</dd></dl>
</li>
</ul>
<a name="affinityRun(java.lang.String, java.lang.Object, org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityRun</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
void&nbsp;affinityRun(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                    <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                 throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).
 </p>
 It's guaranteed that the data of the whole partition, the affinity key belongs to,
 will present on the destination node throughout the job execution.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheName</code> - Name of the cache to use for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityRunAsync(java.lang.String, java.lang.Object, org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityRunAsync</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;&nbsp;affinityRunAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
                                  <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                  <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                                    throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location). The data of the partition where affKey is stored
 will not be migrated from the target node while the job is executed.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheName</code> - Name of the cache to use for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the affinity run.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityRun(java.util.Collection, java.lang.Object, org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityRun</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
void&nbsp;affinityRun(@NotNull
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                    <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                 throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).
 </p>
 It's guaranteed that the data of all the partitions of all participating caches,
 the affinity key belongs to, will present on the destination node throughout the job execution.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache is used for
                   affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityRunAsync(java.util.Collection, java.lang.Object, org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityRunAsync</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;&nbsp;affinityRunAsync(@NotNull
                                  <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                  <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                  <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                                    throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location). The data of the partition where affKey is stored
 will not be migrated from the target node while the job is executed. The data
 of the extra caches' partitions with the same partition number also will not be migrated.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache uses for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the affinity run.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityRun(java.util.Collection, int, org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityRun</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
void&nbsp;affinityRun(@NotNull
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                    int&nbsp;partId,
                                    <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                 throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job on the node where partition is located (the partition is primary on the node)
 </p>
 It's guaranteed that the data of all the partitions of all participating caches,
 the affinity key belongs to, will present on the destination node throughout the job execution.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache is used for
                   affinity co-location.</dd><dd><code>partId</code> - Partition number.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityRunAsync(java.util.Collection, int, org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityRunAsync</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;&nbsp;affinityRunAsync(@NotNull
                                  <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                  int&nbsp;partId,
                                  <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                                    throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job asynchronously on the node where partition is located (the partition is primary on the node)
 The data of the partition will not be migrated from the target node
 while the job is executed. The data of the extra caches' partitions with the same partition number
 also will not be migrated.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache uses for affinity co-location.</dd><dd><code>partId</code> - Partition number.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the affinity run.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityCall(java.lang.String, java.lang.Object, org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityCall</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R&gt;&nbsp;R&nbsp;affinityCall(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
                                      <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                      <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
               throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).
 </p>
 It's guaranteed that the data of the whole partition, the affinity key belongs to,
 will present on the destination node throughout the job execution.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheName</code> - Name of the cache to use for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Job result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityCallAsync(java.lang.String, java.lang.Object, org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityCallAsync</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;&nbsp;affinityCallAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cacheName,
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                    <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location). The data of the partition where affKey is stored
 will not be migrated from the target node while the job is executed.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheName</code> - Name of the cache to use for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the affinity call.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityCall(java.util.Collection, java.lang.Object, org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityCall</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R&gt;&nbsp;R&nbsp;affinityCall(@NotNull
                                      <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                      <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                      <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
               throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job on the node where data for provided affinity key is located
 (a.k.a. affinity co-location).
 </p>
 It's guaranteed that the data of all the partitions of all participating caches,
 the affinity key belongs to, will present on the destination node throughout the job execution.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache uses for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Job result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityCallAsync(java.util.Collection, java.lang.Object, org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityCallAsync</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;&nbsp;affinityCallAsync(@NotNull
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;affKey,
                                    <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job asynchronously on the node where data for provided affinity key is located
 (a.k.a. affinity co-location). The data of the partition where affKey is stored
 will not be migrated from the target node while the job is executed. The data
 of the extra caches' partitions with the same partition number also will not be migrated.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache uses for affinity co-location.</dd><dd><code>affKey</code> - Affinity key.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the affinity call.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityCall(java.util.Collection, int, org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityCall</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R&gt;&nbsp;R&nbsp;affinityCall(@NotNull
                                      <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                      int&nbsp;partId,
                                      <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
               throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job on the node where partition is located (the partition is primary on the node)
 </p>
 It's guaranteed that the data of all the partitions of all participating caches,
 the affinity key belongs to, will present on the destination node throughout the job execution.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache uses for affinity co-location.</dd><dd><code>partId</code> - Partition to reserve.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Job result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="affinityCallAsync(java.util.Collection, int, org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>affinityCallAsync</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;&nbsp;affinityCallAsync(@NotNull
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;cacheNames,
                                    int&nbsp;partId,
                                    <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given job asynchronously on the node where partition is located (the partition is primary on the node)
 The data of the partition will not be migrated from the target node
 while the job is executed. The data of the extra caches' partitions with the same partition number
 also will not be migrated.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>cacheNames</code> - Names of the caches to to reserve the partition. The first cache uses for affinity co-location.</dd><dd><code>partId</code> - Partition to reserve.</dd><dd><code>job</code> - Job which will be co-located on the node with given affinity key.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the affinity call.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="execute(java.lang.Class,java.lang.Object)">
<!--   -->
</a><a name="execute(java.lang.Class, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>execute</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;T,R&gt;&nbsp;R&nbsp;execute(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&gt;&nbsp;taskCls,
                                   @Nullable
                                   T&nbsp;arg)
          throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given task on within the cluster group. For step-by-step explanation of task execution process
 refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskCls</code> - Class of the task to execute. If class has <a href="../../../org/apache/ignite/compute/ComputeTaskName.html" title="annotation in org.apache.ignite.compute"><code>ComputeTaskName</code></a> annotation,
      then task is deployed under a name specified within annotation. Otherwise, full
      class name is used as task name.</dd><dd><code>arg</code> - Optional argument of task execution, can be <code>null</code>.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Task result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task failed.</dd></dl>
</li>
</ul>
<a name="executeAsync(java.lang.Class,java.lang.Object)">
<!--   -->
</a><a name="executeAsync(java.lang.Class, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeAsync</h4>
<pre>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;&nbsp;executeAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&gt;&nbsp;taskCls,
                                      @Nullable
                                      T&nbsp;arg)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given task asynchronously on within the cluster group. For step-by-step explanation of task execution
 process refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskCls</code> - Class of the task to execute. If class has <a href="../../../org/apache/ignite/compute/ComputeTaskName.html" title="annotation in org.apache.ignite.compute"><code>ComputeTaskName</code></a> annotation,
      then task is deployed under a name specified within annotation. Otherwise, full
      class name is used as task name.</dd><dd><code>arg</code> - Optional argument of task execution, can be <code>null</code>.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the task.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task failed.</dd></dl>
</li>
</ul>
<a name="execute(org.apache.ignite.compute.ComputeTask,java.lang.Object)">
<!--   -->
</a><a name="execute(org.apache.ignite.compute.ComputeTask, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>execute</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;T,R&gt;&nbsp;R&nbsp;execute(<a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&nbsp;task,
                                   @Nullable
                                   T&nbsp;arg)
          throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given task within the cluster group. For step-by-step explanation of task execution process
 refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>task</code> - Instance of task to execute. If task class has <a href="../../../org/apache/ignite/compute/ComputeTaskName.html" title="annotation in org.apache.ignite.compute"><code>ComputeTaskName</code></a> annotation,
      then task is deployed under a name specified within annotation. Otherwise, full
      class name is used as task name.</dd><dd><code>arg</code> - Optional argument of task execution, can be <code>null</code>.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Task result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task failed.</dd></dl>
</li>
</ul>
<a name="executeAsync(org.apache.ignite.compute.ComputeTask,java.lang.Object)">
<!--   -->
</a><a name="executeAsync(org.apache.ignite.compute.ComputeTask, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeAsync</h4>
<pre>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;&nbsp;executeAsync(<a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;T,R&gt;&nbsp;task,
                                      @Nullable
                                      T&nbsp;arg)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given task asynchronously within the cluster group. For step-by-step explanation of task execution
 process refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>task</code> - Instance of task to execute. If task class has <a href="../../../org/apache/ignite/compute/ComputeTaskName.html" title="annotation in org.apache.ignite.compute"><code>ComputeTaskName</code></a> annotation,
      then task is deployed under a name specified within annotation. Otherwise, full
      class name is used as task name.</dd><dd><code>arg</code> - Optional argument of task execution, can be <code>null</code>.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the task.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task failed.</dd></dl>
</li>
</ul>
<a name="execute(java.lang.String,java.lang.Object)">
<!--   -->
</a><a name="execute(java.lang.String, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>execute</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;T,R&gt;&nbsp;R&nbsp;execute(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName,
                                   @Nullable
                                   T&nbsp;arg)
          throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given task within the cluster group. For step-by-step explanation of task execution process
 refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation.
 <p>
 If task for given name has not been deployed yet, then <code>taskName</code> will be
 used as task class name to auto-deploy the task (see <a href="../../../org/apache/ignite/IgniteCompute.html#localDeployTask(java.lang.Class,%20java.lang.ClassLoader)"><code>localDeployTask(Class, ClassLoader)</code></a> method).</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskName</code> - Name of the task to execute.</dd><dd><code>arg</code> - Optional argument of task execution, can be <code>null</code>.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Task result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task failed.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>for information about task execution.</code></a></dd></dl>
</li>
</ul>
<a name="executeAsync(java.lang.String,java.lang.Object)">
<!--   -->
</a><a name="executeAsync(java.lang.String, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeAsync</h4>
<pre>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;&nbsp;executeAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName,
                                      @Nullable
                                      T&nbsp;arg)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes given task asynchronously within the cluster group. For step-by-step explanation of task execution
 process refer to <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a> documentation.
 <p>
 If task for given name has not been deployed yet, then <code>taskName</code> will be
 used as task class name to auto-deploy the task (see <a href="../../../org/apache/ignite/IgniteCompute.html#localDeployTask(java.lang.Class,%20java.lang.ClassLoader)"><code>localDeployTask(Class, ClassLoader)</code></a> method).</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskName</code> - Name of the task to execute.</dd><dd><code>arg</code> - Optional argument of task execution, can be <code>null</code>.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the task.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task failed.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>for information about task execution.</code></a></dd></dl>
</li>
</ul>
<a name="broadcast(org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>broadcast</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
void&nbsp;broadcast(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
               throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Broadcasts given job to all nodes in the cluster group.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to broadcast to all cluster group nodes.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="broadcastAsync(org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>broadcastAsync</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;&nbsp;broadcastAsync(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Broadcasts given job asynchronously to all nodes in the cluster group.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to broadcast to all cluster group nodes.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the broadcast execution of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If job failed.</dd></dl>
</li>
</ul>
<a name="broadcast(org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>broadcast</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&nbsp;broadcast(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
                        throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Broadcasts given job to all nodes in cluster group. Every participating node will return a
 job result. Collection of all returned job results is returned from the result future.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to broadcast to all cluster group nodes.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Collection of results for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="broadcastAsync(org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>broadcastAsync</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;&nbsp;broadcastAsync(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
                                           throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Broadcasts given job asynchronously to all nodes in cluster group. Every participating node will return a
 job result. Collection of all returned job results is returned from the result future.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to broadcast to all cluster group nodes.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the broadcast execution of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="broadcast(org.apache.ignite.lang.IgniteClosure,java.lang.Object)">
<!--   -->
</a><a name="broadcast(org.apache.ignite.lang.IgniteClosure, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>broadcast</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R,T&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&nbsp;broadcast(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
                                                 @Nullable
                                                 T&nbsp;arg)
                        throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Broadcasts given closure job with passed in argument to all nodes in the cluster group.
 Every participating node will return a job result. Collection of all returned job results
 is returned from the result future.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to broadcast to all cluster group nodes.</dd><dd><code>arg</code> - Job closure argument.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Collection of results for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="broadcastAsync(org.apache.ignite.lang.IgniteClosure,java.lang.Object)">
<!--   -->
</a><a name="broadcastAsync(org.apache.ignite.lang.IgniteClosure, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>broadcastAsync</h4>
<pre>&lt;R,T&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;&nbsp;broadcastAsync(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
                                               @Nullable
                                               T&nbsp;arg)
                                           throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Broadcasts given closure job asynchronously with passed in argument to all nodes in the cluster group.
 Every participating node will return a job result. Collection of all returned job results
 is returned from the result future.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to broadcast to all cluster group nodes.</dd><dd><code>arg</code> - Job closure argument.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the broadcast execution of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="run(org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>run</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
void&nbsp;run(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
         throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided job on a node within the underlying cluster group.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job closure to execute.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="runAsync(org.apache.ignite.lang.IgniteRunnable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>runAsync</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;&nbsp;runAsync(<a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&nbsp;job)
                            throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided job asynchronously on a node within the underlying cluster group.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job closure to execute.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="run(java.util.Collection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>run</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
void&nbsp;run(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&gt;&nbsp;jobs)
         throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes collection of jobs on grid nodes within the underlying cluster group.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jobs</code> - Collection of jobs to execute.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="runAsync(java.util.Collection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>runAsync</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Void.html?is-external=true" title="class or interface in java.lang">Void</a>&gt;&nbsp;runAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteRunnable.html" title="interface in org.apache.ignite.lang">IgniteRunnable</a>&gt;&nbsp;jobs)
                            throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes collection of jobs asynchronously on grid nodes within the underlying cluster group.
 Executes asynchronously. Returns control immediately.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jobs</code> - Collection of jobs to execute.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="call(org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>call</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R&gt;&nbsp;R&nbsp;call(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
       throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided job on a node within the underlying cluster group. The result of the
 job execution is returned from the result closure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to execute.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Job result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="callAsync(org.apache.ignite.lang.IgniteCallable)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>callAsync</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;&nbsp;callAsync(<a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&nbsp;job)
                          throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided job asynchronously on a node within the underlying cluster group. The result of the
 job execution is returned from the result closure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to execute.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="call(java.util.Collection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>call</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&nbsp;call(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&gt;&nbsp;jobs)
                   throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes collection of jobs on nodes within the underlying cluster group.
 Collection of all returned job results is returned from the result future.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jobs</code> - Collection of jobs to execute.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Collection of job results for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="callAsync(java.util.Collection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>callAsync</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;&nbsp;callAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R&gt;&gt;&nbsp;jobs)
                                      throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes collection of jobs asynchronously on nodes within the underlying cluster group.
 Collection of all returned job results is returned from the result future.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jobs</code> - Collection of jobs to execute.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="call(java.util.Collection, org.apache.ignite.lang.IgniteReducer)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>call</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R1,R2&gt;&nbsp;R2&nbsp;call(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R1&gt;&gt;&nbsp;jobs,
                                   <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)
        throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes collection of jobs on nodes within the underlying cluster group. The returned
 job results will be reduced into an individual result by provided reducer.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jobs</code> - Collection of jobs to execute.</dd><dd><code>rdc</code> - Reducer to reduce all job results into one individual return value.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Reduced job result for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="callAsync(java.util.Collection, org.apache.ignite.lang.IgniteReducer)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>callAsync</h4>
<pre>&lt;R1,R2&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R2&gt;&nbsp;callAsync(<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../org/apache/ignite/lang/IgniteCallable.html" title="interface in org.apache.ignite.lang">IgniteCallable</a>&lt;R1&gt;&gt;&nbsp;jobs,
                                 <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)
                           throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes collection of jobs asynchronously on nodes within the underlying cluster group. The returned
 job results will be reduced into an individual result by provided reducer.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jobs</code> - Collection of jobs to execute.</dd><dd><code>rdc</code> - Reducer to reduce all job results into one individual return value.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future with reduced job result for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="apply(org.apache.ignite.lang.IgniteClosure,java.lang.Object)">
<!--   -->
</a><a name="apply(org.apache.ignite.lang.IgniteClosure, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>apply</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R,T&gt;&nbsp;R&nbsp;apply(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
                                 @Nullable
                                 T&nbsp;arg)
        throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided closure job on a node within the underlying cluster group. This method is different
 from <code>run(...)</code> and <code>call(...)</code> methods in a way that it receives job argument
 which is then passed into the closure at execution time.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to run.</dd><dd><code>arg</code> - Job argument.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Job result.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="applyAsync(org.apache.ignite.lang.IgniteClosure,java.lang.Object)">
<!--   -->
</a><a name="applyAsync(org.apache.ignite.lang.IgniteClosure, T)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>applyAsync</h4>
<pre>&lt;R,T&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R&gt;&nbsp;applyAsync(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
                               @Nullable
                               T&nbsp;arg)
                           throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided closure job asynchronously on a node within the underlying cluster group.
 This method is different from <code>run(...)</code> and <code>call(...)</code> methods in a way that
 it receives job argument which is then passed into the closure at execution time.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to run.</dd><dd><code>arg</code> - Job argument.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="apply(org.apache.ignite.lang.IgniteClosure, java.util.Collection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>apply</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;T,R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&nbsp;apply(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
                                             <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args)
                    throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided closure job on nodes within the underlying cluster group. A new job is executed for
 every argument in the passed in collection. The number of actual job executions will be
 equal to size of the job arguments collection.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to run.</dd><dd><code>args</code> - Job arguments.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Collection of job results.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="applyAsync(org.apache.ignite.lang.IgniteClosure, java.util.Collection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>applyAsync</h4>
<pre>&lt;T,R&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;R&gt;&gt;&nbsp;applyAsync(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R&gt;&nbsp;job,
                                           <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args)
                                       throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided closure job asynchronously on nodes within the underlying cluster group. A new job is executed
 for every argument in the passed in collection. The number of actual job executions will be
 equal to size of the job arguments collection.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to run.</dd><dd><code>args</code> - Job arguments.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future representing pending completion of the job.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="apply(org.apache.ignite.lang.IgniteClosure, java.util.Collection, org.apache.ignite.lang.IgniteReducer)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>apply</h4>
<pre><a href="../../../org/apache/ignite/lang/IgniteAsyncSupported.html" title="annotation in org.apache.ignite.lang">@IgniteAsyncSupported</a>
&lt;R1,R2,T&gt;&nbsp;R2&nbsp;apply(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R1&gt;&nbsp;job,
                                      <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args,
                                      <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)
         throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided closure job on nodes within the underlying cluster group. A new job is executed for
 every argument in the passed in collection. The number of actual job executions will be
 equal to size of the job arguments collection. The returned job results will be reduced
 into an individual result by provided reducer.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to run.</dd><dd><code>args</code> - Job arguments.</dd><dd><code>rdc</code> - Reducer to reduce all job results into one individual return value.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Reduced job result for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="applyAsync(org.apache.ignite.lang.IgniteClosure, java.util.Collection, org.apache.ignite.lang.IgniteReducer)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>applyAsync</h4>
<pre>&lt;R1,R2,T&gt;&nbsp;<a href="../../../org/apache/ignite/lang/IgniteFuture.html" title="interface in org.apache.ignite.lang">IgniteFuture</a>&lt;R2&gt;&nbsp;applyAsync(<a href="../../../org/apache/ignite/lang/IgniteClosure.html" title="interface in org.apache.ignite.lang">IgniteClosure</a>&lt;T,R1&gt;&nbsp;job,
                                    <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends T&gt;&nbsp;args,
                                    <a href="../../../org/apache/ignite/lang/IgniteReducer.html" title="interface in org.apache.ignite.lang">IgniteReducer</a>&lt;R1,R2&gt;&nbsp;rdc)
                            throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Executes provided closure job asynchronously on nodes within the underlying cluster group. A new job is executed
 for every argument in the passed in collection. The number of actual job executions will be
 equal to size of the job arguments collection. The returned job results will be reduced
 into an individual result by provided reducer.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>job</code> - Job to run.</dd><dd><code>args</code> - Job arguments.</dd><dd><code>rdc</code> - Reducer to reduce all job results into one individual return value.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a Future with reduced job result for this execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If execution failed.</dd></dl>
</li>
</ul>
<a name="activeTaskFutures()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>activeTaskFutures</h4>
<pre>&lt;R&gt;&nbsp;<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="../../../org/apache/ignite/lang/IgniteUuid.html" title="class in org.apache.ignite.lang">IgniteUuid</a>,<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;&gt;&nbsp;activeTaskFutures()</pre>
<div class="block">Gets tasks future for active tasks started on local node.</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>Map of active tasks keyed by their task task session ID.</dd></dl>
</li>
</ul>
<a name="withName(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>withName</h4>
<pre><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a>&nbsp;withName(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName)</pre>
<div class="block">Sets task name for the next executed task in the <b>current thread</b>.
 When task starts execution, the name is reset, so one name is used only once. You may use
 this method to set task name when executing jobs directly, without explicitly
 defining <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a>.
 <p>
 Here is an example.
 <pre name="code" class="java">
 ignite.withName("MyTask").run(new IgniteRunnable() {...});
 </pre></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskName</code> - Task name.</dd>
<dt><span class="strong">Returns:</span></dt><dd>This <code>IgniteCompute</code> instance for chaining calls.</dd></dl>
</li>
</ul>
<a name="withTimeout(long)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>withTimeout</h4>
<pre><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a>&nbsp;withTimeout(long&nbsp;timeout)</pre>
<div class="block">Sets task timeout for the next executed task in the <b>current thread</b>.
 When task starts execution, the timeout is reset, so one timeout is used only once. You may use
 this method to set task name when executing jobs directly, without explicitly
 defining <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute"><code>ComputeTask</code></a>.
 <p>
 Here is an example.
 <pre class="brush:java">
 ignite.withTimeout(10000).run(new IgniteRunnable() {...});
 </pre></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>timeout</code> - Computation timeout in milliseconds.</dd>
<dt><span class="strong">Returns:</span></dt><dd>This <code>IgniteCompute</code> instance for chaining calls.</dd></dl>
</li>
</ul>
<a name="withNoFailover()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>withNoFailover</h4>
<pre><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a>&nbsp;withNoFailover()</pre>
<div class="block">Sets no-failover flag for the next task executed in the <b>current thread</b>.
 If flag is set, job will be never failed over even if remote node crashes or rejects execution.
 When task starts execution, the no-failover flag is reset, so all other task will use default
 failover policy, unless this flag is set again.
 <p>
 Here is an example.
 <pre name="code" class="java">
 ignite.compute().withNoFailover().run(new IgniteRunnable() {...});
 </pre></div>
<dl><dt><span class="strong">Returns:</span></dt><dd>This <code>IgniteCompute</code> instance for chaining calls.</dd></dl>
</li>
</ul>
<a name="localDeployTask(java.lang.Class, java.lang.ClassLoader)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>localDeployTask</h4>
<pre>void&nbsp;localDeployTask(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&gt;&nbsp;taskCls,
                   <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html?is-external=true" title="class or interface in java.lang">ClassLoader</a>&nbsp;clsLdr)
                     throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Explicitly deploys a task with given class loader on the local node. Upon completion of this method,
 a task can immediately be executed on the grid, considering that all participating
 remote nodes also have this task deployed.
 <p>
 Note that tasks are automatically deployed upon first execution (if peer-class-loading is enabled),
 so use this method only when the provided class loader is different from the
 <code>taskClass.getClassLoader()</code>.
 <p>
 Another way of class deployment is deployment from local class path.
 Classes from local class path always have a priority over P2P deployed ones.
 <p>
 Note that class can be deployed multiple times on remote nodes, i.e. re-deployed. Ignition
 maintains internal version of deployment for each instance of deployment (analogous to
 class and class loader in Java). Execution happens always on the latest deployed instance.
 <p>
 This method has no effect if the class passed in was already deployed.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskCls</code> - Task class to deploy. If task class has <a href="../../../org/apache/ignite/compute/ComputeTaskName.html" title="annotation in org.apache.ignite.compute"><code>ComputeTaskName</code></a> annotation,
      then task will be deployed under the name specified within annotation. Otherwise, full
      class name will be used as task's name.</dd><dd><code>clsLdr</code> - Task class loader. This class loader is in charge
      of loading all necessary resources for task execution.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - If task is invalid and cannot be deployed.</dd></dl>
</li>
</ul>
<a name="localTasks()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>localTasks</h4>
<pre><a href="http://docs.oracle.com/javase/7/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/ignite/compute/ComputeTask.html" title="interface in org.apache.ignite.compute">ComputeTask</a>&lt;?,?&gt;&gt;&gt;&nbsp;localTasks()</pre>
<div class="block">Gets map of all locally deployed tasks keyed by their task name .</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>Map of locally deployed tasks keyed by their task name.</dd></dl>
</li>
</ul>
<a name="undeployTask(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>undeployTask</h4>
<pre>void&nbsp;undeployTask(<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;taskName)
                  throws <a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></pre>
<div class="block">Makes the best attempt to undeploy a task with given name within the underlying cluster group.
 Note that this method returns immediately and does not wait until the task will actually be
 undeployed on every node.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>taskName</code> - Name of the task to undeploy.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../org/apache/ignite/IgniteException.html" title="class in org.apache.ignite">IgniteException</a></code> - Thrown if undeploy failed.</dd></dl>
</li>
</ul>
<a name="future()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>future</h4>
<pre><a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
&lt;R&gt;&nbsp;<a href="../../../org/apache/ignite/compute/ComputeTaskFuture.html" title="interface in org.apache.ignite.compute">ComputeTaskFuture</a>&lt;R&gt;&nbsp;future()</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;</div>
<div class="block">Gets and resets future for previous asynchronous operation.</div>
<dl>
<dt><strong>Specified by:</strong></dt>
<dd><code><a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html#future()">future</a></code>&nbsp;in interface&nbsp;<code><a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html" title="interface in org.apache.ignite.lang">IgniteAsyncSupport</a></code></dd>
<dt><span class="strong">Returns:</span></dt><dd>Future for previous asynchronous operation.</dd></dl>
</li>
</ul>
<a name="withAsync()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>withAsync</h4>
<pre><a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
<a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a>&nbsp;withAsync()</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;</div>
<div class="block">Gets instance of this component with asynchronous mode enabled.</div>
<dl>
<dt><strong>Specified by:</strong></dt>
<dd><code><a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html#withAsync()">withAsync</a></code>&nbsp;in interface&nbsp;<code><a href="../../../org/apache/ignite/lang/IgniteAsyncSupport.html" title="interface in org.apache.ignite.lang">IgniteAsyncSupport</a></code></dd>
<dt><span class="strong">Returns:</span></dt><dd>Instance of this component with asynchronous mode enabled.</dd></dl>
</li>
</ul>
<a name="withExecutor(java.lang.String)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>withExecutor</h4>
<pre><a href="../../../org/apache/ignite/IgniteCompute.html" title="interface in org.apache.ignite">IgniteCompute</a>&nbsp;withExecutor(@NotNull
                         <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Gets instance of the compute API associated with custom executor. All tasks and closures submitted to returned
 instance will be processed by this executor on both remote and local nodes. If executor with the given name
 doesn't exist, task will be processed in default ("public") pool.
 <p>
 Executor should be defined in <a href="../../../org/apache/ignite/configuration/IgniteConfiguration.html#setExecutorConfiguration(org.apache.ignite.configuration.ExecutorConfiguration...)"><code>IgniteConfiguration.setExecutorConfiguration(ExecutorConfiguration...)</code></a>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>name</code> - Custom executor name.</dd>
<dt><span class="strong">Returns:</span></dt><dd>Instance of compute API associated with custom executor.</dd></dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!--   -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/IgniteCompute.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../index-all.html">Index</a></li>
<li><a href="../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em>Ignite - In-Memory Data Fabric</em></div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../org/apache/ignite/IgniteCluster.html" title="interface in org.apache.ignite"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../org/apache/ignite/IgniteCondition.html" title="interface in org.apache.ignite"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?org/apache/ignite/IgniteCompute.html" target="_top">Frames</a></li>
<li><a href="IgniteCompute.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small><table width="100%" border="0" cellspacing=0 cellpadding=0 style="padding: 5px">                                     <tr>                                         <td>                                             <table style="padding-left: 0; margin: 0">                                                 <tbody style="padding: 0; margin: 0">                                                     <tr style="padding: 0; margin: 0">                                                         <td>                                                             <a target=_blank href="https://ignite.apache.org"><nobr>2017 Copyright &#169; Apache Software Foundation</nobr></a>                                                         </td>                                                     </tr>                                                 </tbody>                                             </table>                                         </td>                                         <td width="100%" align="right" valign="center">                                             <a href="https://twitter.com/ApacheIgnite" class="twitter-follow-button" data-show-count="false" data-size="large">Follow @ApacheIgnite</a>                                         </td>                                     </tr>                                     <tr>                                         <td colspan="2" valign="top" align="left">                                             <table style="padding-left: 0; margin: 0">                                                 <tbody style="padding: 0; margin: 0">                                                     <tr style="padding: 0; margin: 0">                                                         <td>                                                             <b>Ignite Fabric</b>                                                         </td>                                                         <td>:&nbsp;&nbsp;                                                             ver. <strong>2.0.0</strong>                                                         </td>                                                     </tr>                                                     <tr style="padding: 0; margin: 0">                                                         <td>                                                             <b>Release Date</b>                                                         </td>                                                         <td>:&nbsp;&nbsp;                                                             April 30 2017                                                         </td>                                                     </tr>                                                 </tbody>                                             </table>                                         </td>                                     </tr>                                     </table></small></p>
</body>
</html>
