Ignite 名词析意

1.ClusterNode（接口）

1.1 总体概述

表示单个集群节点的接口。你可以使用attribute（String name）和metrics()方法来获取静态或者动态的集群节点信息。包括任务拓扑中的所有节点的ClusterNode的List列表，会被传递给org.apache.ignite.compute.ComputeTask的map(List<\ClusterNode> subgrid, @Nullable T arg)方法，作为其入参，而这个map()方法被调用时用来映射或者分解网格task（grid task）成多重的网格job（grid job），这是当任务执行开始时调用的第一个方法。您可以使用群集节点属性提供有关节点的静态信息.此信息在节点启动时在集群中初始化，在节点的整个生命周期中保持不变。你可以使用IgniteConfiguration#getUserAttributes()这个方法，在启动的时候，初始化你自定义的节点。下面是一个如何在启动时为节点分配属性的示例:

<bean class="org.apache.ignite.configuration.IgniteConfiguration">    ...    <propertiy name="userAttributes">        <map>            <entry key="worker" value="true"/>        </map>    </property>    ...</bean>

系统自动添加以下属性:1.System#getProperties(),即全部的系统属性2.System#getenv(String)，即所有的环境属性3.org.ignite.build.ver，即Ignite版本号4.org.apache.ignite.jit.name，即使用的JIT编译器的名称5.org.apache.ignite.net.itf.name，即网络接口的名称6.org.apache.ignite.user.name，即操作系统用户名7.org.apache.ignite.ignite.name，即ignite的名字，参考Ignite#name()这个方法8.spiName.org.apache.ignite.spi.class，即每个SPI的SPI实现类。org.apache.ignite.spi.IgniteSpi#getName可以获取到SPI的名字，就是spiname.org.apache.ignite.spi.class里的那个spiname这个单词的实际参数9.spiName.org.apache.ignite.spi.ver，即每个SPI的SPI版本。注意，所有节点的所有系统和环境属性都将自动包含到节点属性中，这使得你可以获取到任何关于节点的配置信息。例如，为了打印出操作系统的信息，你可以像下面这样来操作：

for (ClusterNode node : ignite.cluster().nodes()) {    System.out.println("Operating system name: " + node.getAttribute("os.name"));    System.out.println("Operating system architecture: " + node.getAttribute("os.arch"));    System.out.println("Operating system version: " + node.getAttribute("os.version"));}

集群节点指标(可以使用metrics（）方法来获取到)对所有节点经常更新，并且可以用来获取关于节点的动态信息。更新的频率是受org.apache.ignite.configuration.IgniteConfiguration#getMetricsUpdateFrequency()参数来控制的。默认的情况下，是没两秒更新一次。网格节点指标（metrics）提供了经常会变化的信息，例如堆和非堆内存使用，CPU负载、活跃和等待的数量网格jobs,etc....这些信息有时很有用，例如：在解决工作冲突，或者org.apache.ignite.compute.ComputeTask#map(List, Object)方法在jobs被分配给远程节点执行时候的操作。本地节点指标被标记为MBean，可以从任何JMX管理控制台访问。最简单的方法是使用JDK附带的标准jconsole，因为它还提供了将任何节点参数视为图形的能力

1.2 方法讲解

1.2.1 public UUID id();

获取全局唯一的节点ID。每当节点重新启动时，都会生成一个新ID。

1.2.2 public Object consistentId();

获得一致的全局唯一节点ID。他不像id()方法，此方法返回一致的节点ID，该ID可以在节点重新启动时保存

1.2.3 @Nullable public <\T> T attribute(String name);

获取一个节点的属性。属性在启动时通过IgniteConfiguration#getUserAttributes()方法被分配给节点。系统自动添加许多属性，所有的属性都是以org.apache.ignite.internal.IgniteNodeAttributes来定义的。注意，属性不能在运行时更改。

1.2.4 public ClusterMetrics metrics();

获取该节点的指标快照。注意，节点度量是不断更新的，并提供关于节点的最新信息。例如，你可以在org.apache.ignite.compute.ComputeTask#map(List, Object)方法期间或者出现冲突的时候，用ClusterMetrics#getCurrentCpuLoad()方法来获取到CPU的信息。

1.2.5 public Map

1.2.6 public Collection<\String> addresses();、

获取这个节点所知道的地址的集合。如果IgniteConfiguration#getLocalHost()的值不是null，那么节点会尝试去使用这个地址在所有通信中，并且返回的集合只包含该地址。但是如果它是null的话，将使用本地通配符地址，ignite在返回的集合中，将尽最大努力提供该节点的所有地址.

1.2.7 public Collection hostNames();

获取该节点所知道的主机名的集合。如果IgniteConfiguration#getLocalHost()返回的值不是空，那么ignite就会尝试使用这个主机名用于所有通信已解析的地址，返回的集合只包含主机名。如果无法解析主机名，则通过addresses()方法返回ip地址。但是如果这个方法的返回值返回的数据是个空，将使用本地通配符地址，这个方法返回该节点的所有地址的主机名。注意:在结果中将省略环回地址。

1.2.8 public long order();

网格拓扑中的节点顺序。发现的SPIs支持节点排序将为每个节点分配一个适当的顺序，并保证新节点的发现事件通知将按正确顺序出现。所有其他不支持排序的SPIs可以选择在这里返回节点启动时间。注意：在发现的SPI不支持排序的情况下，ignite不可以保证所有节点上的命令将是唯一的或按时间顺序正确的。如果这是必须的---确保使用发现SPI提供了排序

1.2.9 public IgniteProductVersion version();

得到节点的版本。

1.2.10 public boolean isLocal();

测试此节点是否为本地节点。

1.2.11 public boolean isDaemon();

测试此节点是否为守护进程。守护进程节点是通常的集群节点，它们参与到拓扑中，但在主api中不可见。它们不是任何集群组的一部分。唯一的查看守护节点的方法是IgniteCluster#forDaemons()。守护进程节点主要用于管理和监视功能，这些功能是在点火时构建的，需要参与到拓扑中，但是应该被排除在“常规”拓扑之外，这样它们就不会参与到任务执行或数据网格操作中了。应用程序代码永远不应该使用守护进程节点

1.2.12 public boolean isClient();

测试此节点是否与集群作为客户机连接。不要混淆通过DiscoverySpi#isClientMode(方法的作用是：是否在客户端模式中开始发现)，以及IgniteConfiguration#isClientMode(方法的作用：客户端模式的标识。客户端节点不能在缓存中保存数据。如果这个方法返回了True，那么建议在客户端模式下使用DiscoverySpi)所表达的意思。缓存客户端不能携带数据，而拓扑客户端以不同的方式连接到拓扑。

2.TcpDiscoveryNode（类）

TcpDiscoverySpi的node节点

3. IgniteSpi（接口）

SPI(Serial Peripheral Interface--串行外设接口)总线系统是一种同步串行外设接口，它可以使MCU与各种外围设备以串行方式进行通信以交换信息。SPI有三个寄存器分别为：控制寄存器SPCR，状态寄存器SPSR，数据寄存器SPDR。外围设备包括FLASHRAM、网络控制器、LCD显示驱动器、A/D转换器和MCU等。SPI总线系统可直接与各个厂家生产的多种标准外围器件直接接口，该接口一般使用4条线：串行时钟线（SCLK）、主机输入/从机输出数据线MISO、主机输出/从机输入数据线MOSI和低电平有效的从机选择线NSS(有的SPI接口芯片带有中断信号线INT、有的SPI接口芯片没有主机输出/从机输入数据线MOSI)。    --------------------baidu

3.1 概述

这个接口定义了SPI实现的生命周期,每个SPI实现都应该实现这个接口。内核不会加载不实现该接口的SPI。网格SPI可以使用IoC进行注入(DI)ignite的resource，基于方法的和基于属性的注入，这两种方法都是支持的。如下的ignite资源可以被注入进去：1.org.apache.ignite.resources.LoggerResource2.org.apache.ignite.resources.SpringApplicationContextResource3.org.apache.ignite.resources.SpringResource有关更多信息，请参考相应的资源文档。

3.2 方法解析

3.2.1 public String getName();

得到了SPI的名字

3.2.2 public Map

3.2.3 public void spiStart(@Nullable String igniteInstanceName) throws IgniteSpiException;

该方法被调用来启动SPI。在此方法返回成功后，内核假定SPI是完全可操作的。这个方法的入参：    igniteInstanceName：这个SPI正在开始的ignite实例的名字 

3.2.4 public void onContextInitialized(IgniteSpiContext spiCtx) throws IgniteSpiException;

在初始化SPI上下文时调用回调。SPI实现可以存储SPI上下文以备将来访问。此方法将在spiStart(String)成功以后以后调用，因此在这一点上，SPI应该是完全有功能的。使用此方法进行启动后的初始化，例如订阅一个发现侦听器、向远程节点发送消息等。入参： Spi context

3.2.5 public void onContextDestroyed();

在SPI上下文被破坏之前的停止网格之前调用回调。一旦此方法完成，网格将开始关闭序列。使用这个回调逻辑来处理可能涉及SPI上下文的反初始化逻辑。在这个回调完成之后调用SPI上下文被认为是非法的，可能产生未知的结果。如果IgniteSpiAdapter用于SPI实现，然后，它将替换实际的上下文，使用虚拟的无操作上下文，这通常足够好，因为网格即将关闭。

3.2.6 public void spiStop() throws IgniteSpiException;

这种方法被称为停止SPI。在此方法返回后，内核假定该SPI已经结束了，并且它所获得的所有资源都将被释放。注意，这个方法可以在任何时候调用，包括在恢复失败的开始时。当这个方法被调用时，它不应该对SPI处于什么状态进行假设，即不会在意SPI的当前状态。

3.2.7 public void onClientDisconnected(IgniteFuture

3.2.8 public void onClientReconnected(boolean clusterRestarted);

客户机节点连接的回调

4.EventStorageSpi（接口）

4.1 概述

此SPI提供本地节点事件存储。SPI允许记录本地节点事件并查询记录的本地事件。在其生命周期中，每个节点都经历了一些严重的事件，比如任务部署、任务执行、作业执行。由于性能原因，ignite的目的是将本地生产的所有事件都存储在本地。可以使用分布式查询来检索这些事件:org.apache.ignite.IgniteEvents#remoteQuery(org.apache.ignite.lang.IgnitePredicate, long, int...)或者当地唯一的查询：org.apache.ignite.IgniteEvents#localQuery(org.apache.ignite.lang.IgnitePredicate, int...)注意：这个SPI（EventStorageSpi）里的方法不应该被直接使用。SPIs提供了子系统的内部视图，并在内部使用ignite内核。在罕见的用例中，当需要访问这个SPI的特定实现时----这个SPI的实例可以通过org.apache.ignite.Ignite#configuration()方法检查它的配置属性，或者调用其他非spi方法的方式被获取到。请注意，对实现了这个接口的实例调用方法可以导致未定义的行为，并且显式地不支持。

4.2 方法

4.2.1 public <\T extends Event> Collection localEvents(IgnitePredicate p);

查询本地事件。事件可以通过给定谓词过滤被过滤掉

4.2.2 public void record(Event evt) throws IgniteSpiException;

单独的事件记录。

5. IgniteEvents（接口）

5.1 概述

为在由于clusterGroup()定义的节点上提供本地和远程事件通知的功能。这里有两种方式订阅事件监听，local本地的和remote远程的。IgniteEvents的实例从Ignite里获取，获取方式如下：

    Ignite ignite = Ignition.ignite();    IgniteEvents evts = ignite.events();

您还可以通过一个指定的集群组获得事件facade实例，即IgniteEvent:

    //在远程节点上的集群组(不包括本地节点)    ClusterGroup remoteNodes = ignite.cluster().forRemotes();    //跨越所有远程集群节点的事件实例    IgniteEvents evts = ignite.events(remoteNodes);

本地订阅,由localListen(IgnitePredicate, int...)方法定义，将会添加一个监听器为那些仅仅发生在本地节点上的指定的事件。当任何订阅事件发生在本地节点上时，不管本地节点是否属于底层节点，该侦听器都会被通知。远程订阅，由remoteListen(IgniteBiPredicate, IgnitePredicate, int...)方法定义，会在集群组中的所有节点上为指定的事件添加一个事件监听器（如果它属于集群组，可能包括本地节点）。然后，所有集群组节点将被通知订阅事件。如果事件通过远程事件过滤器，事件将被发送到本地节点以进行本地侦听器通知。请注意，在默认情况下，由于性能的原因，ignite的所有事件都是禁用的。比必须在你的逻辑中，使你需要的事件变为可用。你可以用enableLocal(int...)方法使事件可用或者不可用，或者你可以使用XML配置。例如，您可以启用所有缓存事件如下:：

    <property name="includeEventTypes">        <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVTS_CACHE"/>    </property>

5.2 方法

5.2.1 public ClusterGroup clusterGroup();

根据IgniteEvents实例的归属，获取相应的集群组。

5.2.2 public <\T extends Event> List<\T> remoteQuery(IgnitePredicate<\T> p, long timeout, @Nullable int… types)throws IgniteException;

在这个集群组中的节点，用指定的谓词过滤器进行事件类型过滤的的查询操作。参数：    IgnitePredicate p：用于查询远程节点上事件的谓词过滤器。    long timeout:最大时间等待结果,如果是0，标识一致等待，不超时    int... types：要查询的事件类型返回值：从指定节点返回的网格事件集合

5.2.3 public < T extends Event> IgniteFuture remoteQueryAsync(IgnitePredicate < T> p, long timeout, @Nullable int… types) throws IgniteException;

在这个集群组中的节点，根据传入的时间类型，使用指定的谓词过滤器进行过滤的这种异步查询操作。参数：    IgnitePredicate p:用于查询远程节点上事件的谓词过滤器    long timeou:最大时间等待结果.如果是0，标识一致等待，不超时    int... types：要查询的事件类型返回值：表示查询完成的未来的一个结果。完整的future包含从指定节点返回的网格事件的集合。

5.2.4 public <\T extends Event> UUID remoteListen(@Nullable IgniteBiPredicate

5.2.5 public <\T extends Event> IgniteFuture<\UUID> remoteListenAsync(@Nullable IgniteBiPredicate

5.2.6 public <\T extends Event> UUID remoteListen(int bufSize,long interval,boolean autoUnsubscribe,@Nullable IgniteBiPredicate

5.2.7 public <\T extends Event> IgniteFuture<\UUID> remoteListenAsync(int bufSize,long interval,boolean autoUnsubscribe,@Nullable IgniteBiPredicate

5.2.8 public void stopRemoteListen(UUID opId) throws IgniteException;

停止对远程事件的监听。这将取消在clusterGroup方法定义的所有节点上识别的所有监听器的所有侦听器。支持异步执行（参考IgniteAsyncSupport）参数：    UUID opId：remoteListen(IgniteBiPredicate, IgnitePredicate, int...)方法返回的唯一的Operation ID

5.2.9 public IgniteFuture<\Void> stopRemoteListenAsync(UUID opId) throws IgniteException;

异步的取消对于远程事件的监听。这将取消在clusterGroup方法定义的所有节点上识别的所有监听器的所有侦听器。支持异步执行（参考IgniteAsyncSupport）。参数：    UUID opId：remoteListen(IgniteBiPredicate, IgnitePredicate, int...)方法返回的唯一的Operation ID

5.2.10 public <\T extends Event> T waitForLocal(@Nullable IgnitePredicate<\T> filter, @Nullable int… types) throws IgniteException;

等待指定的事件支持异步执行（参考IgniteAsyncSupport）。参数：    IgnitePredicate：可选过滤谓词。只有当谓词的值为true时，事件才会结束等待    int... types：等待的时间的类型。如果没有指定，所有事件都将传递给过滤器。返回值：网格事件Grid event

5.2.11 public <\T extends Event> IgniteFuture<\T> waitForLocalAsync(@Nullable IgnitePredicate<\T> filter, @Nullable int… types) throws IgniteException;

参考上面的方法，就是异步版本。

5.2.12 public <\T extends Event> Collection<\T> localQuery(IgnitePredicate<\T> p, @Nullable int… types);

在本地节点上，查询那些满足于所传入的谓词过滤器的事件参数：    IgnitePredicate<T> p：过滤事件的谓词。所有谓词必须返回筛选条件的事件    int... types：要查询的事件类型返回值：    满足过滤条件的事件的集合

5.2.13 public void recordLocal(Event evt);

记录客户生成的事件。所有注册的本地侦听器将被通知。注意：ignite内部的事件的所有类型(1-1000的都是保留的)，不应该被用户定义的事件使用。尝试用该方法记录内部事件将导致IllegalArgumentException异常被抛出。参数：    Event evt：在本地生成的事件。

5.2.14 public void localListen(IgnitePredicate

5.2.15 public boolean stopLocalListen(IgnitePredicate

5.2.16 public void enableLocal(int… types);

使所提供的事件变得可用。该方法还是可以让之前失效的事件变为可用。注意：指定的事件将会变为可用，无论本地节点是否在集群组内。参数：    int... types：使其变为可用的事件类型

5.2.17 public void disableLocal(int… types);

与上个方法相反，这个是使之失效的。

5.2.18 public int[] enabledEvents();

获取启用事件的类型。

5.2.19 public boolean isEnabled(int type);

检查该事件是否启动了可用性

5.2.20 public IgniteEvents withAsync();

这个方法已经没有了，因为现在该类不集成异步的接口了。

6.Event（接口）

6.1 概述

网格事件用于通知网格中发生的事情.注意，通过设计，ignite将本地节点上的所有事件都保存在本地节点上，并且它提供了在多个节点上执行分布式查询的api:1.org.apache.ignite.IgniteEvents#remoteQuery(org.apache.ignite.lang.IgnitePredicate, long, int...)查询事件发生在指定的节点上，包括远程节点。2.org.apache.ignite.IgniteEvents#localQuery(org.apache.ignite.lang.IgnitePredicate, int...)只查询存储在本地节点上的本地事件3.org.apache.ignite.IgniteEvents#localListen(org.apache.ignite.lang.IgnitePredicate, int...)监听本地网格中的事件（不包括来自远程节点的事件）<事件与性能>注意：默认情况下，ignite中的事件都是启动的，但是事件的生成和存储，在SPI中是可以配置的。ignite 可以在负载下每秒钟产生数千个事件因此它在系统上产生了额外的负载,如果应用程序不需要这些事件，那么负载是不必要的，并导致显著的性能下降。在Ignite的配置中使用org.apache.ignite.configuration.IgniteConfiguration#getIncludeEventTypes()方法，只启用应用程序逻辑所需的那些事件是非常推荐的。如果ignite的内部操作需要某些事件，那么这些事件仍然会生成，但如果在ignite配置中禁用，则不会被事件存储SPI所存储。<内部和隐藏的事件>还要注意，一些事件被认为是内部使用或隐藏的。内部使用的事件总是“可记录的”用于通知目的(不管它们是否被启用或禁用).但是如果用户特别的将其排除在外，那么该事件不会发送给存储事件的SPI的级别。发现的所有事件都是内部：    1.EventType#EVT_NODE_FAILED    2.EventType#EVT_NODE_LEFT    3.EventType#EVT_NODE_JOINED    4.EventType#EVT_NODE_METRICS_UPDATED    5.EventType#EVT_NODE_SEGMENTED隐藏事件，不会发送到SPI的级别。它们为本地节点提供本地通知的目的。隐藏事件：    EventType#EVT_NODE_METRICS_UPDATED

6.2 方法

6.2.1 public IgniteUuid id();

得到这个事件的全局唯一ID

6.2.2 public long localOrder();

获取本地惟一的ID，为每个事件原子递增。但是它不像上面的id()，这个本地ID可以用于在这个节点上排序事件请注意，出于性能考虑，ignite不能在全局上进行排序。

6.2.3 public ClusterNode node();

事件发生和记录的节点返回值：事件发生的地点和记录

6.2.4 public String message();

为该事件获取可选消息返回值：某个事件的消息（可以为null）

6.2.5 public int type();

得到这个事件的类型。所有系统事件类型都定义在EventType类里。所有类型的范围从1到1000都预留给内部的ignite事件，不应该被用户定义的事件使用。

6.2.6 public String name();

获取该事件的名称。所有的事件都在EventType 类中定义。

6.2.7 public long timestamp();

得到事件的时间戳。时间戳是该事件产生的节点的本地的。注意，可以使用相同的时间戳生成多个事件。如果是排序目的，可以使用localOrder()方法来替代。

6.2.8 public String shortDisplay();

获取一个toString()方法结果的简短易读的结果。适合人类阅读

7.EventType（接口）

包含事件类型的常量。决定使用类而不是枚举，是想允许用户创建自己的事件和/或事件类型，这在枚举中是不可能的。这个接口不仅仅知识可以定义个别类型的常量，还可以方便的使用IgniteEvents#localListen(IgnitePredicate, int...)方法定义类型的数组。//都是参数，拿重点的举起栗子：1.public static final int[] EVTS_CHECKPOINT = {    EVT_CHECKPOINT_SAVED,    EVT_CHECKPOINT_LOADED,    EVT_CHECKPOINT_REMOVED};所有检查点事件，这个数组是可以直接诶传递给IgniteEvents#localListen(IgnitePredicate, int...)方法的，来订阅者所有的检查点事件。

8.ComputeTask

8.1 概述：

Grid任务接口定义了可以在网格上执行的任务。Grid task负责将业务逻辑拆分为多个Grid job.接收在远程节点上执行的单个网格作业的结果，并减少(聚合)接收到的作业结果为最终的网格任务结果。<网格任务执行顺序>1.当以给定的任务名称系统去请求执行网格任务时，将会找到以给定名称的部署的任务。任务需要在执行之前部署(参考org.apache.ignite.IgniteCompute#localDeployTask(Class, ClassLoader)方法)。但是，如果任务没有以@ComputeTaskName注解明确指定它的名字，它将在第一次执行时自动部署2.系统将创建新的分布式任务会话（参考ComputeTaskSession）3.系统将注入所有带注释的资源（包括任务的session）进网格任务实例，可以看org.apache.ignite.resources，将需要注入的资源进行打包。4.系统将应用map(List, Object)方法。该方法负责将网格任务的业务逻辑划分为多个网格任务（单位的执行），并将其映射到节点上。map(List, Object)方法的返回值，网格任务作为键，而节点作为值。5.系统将把映射网格作业发送到各自的节点。6.到达远程节点时，网格作业将会被org.apache.ignite.spi.collision.CollisionSpi处理，这个SPI是确定如何在远程节点上执行作业（立即,缓冲或取消）7.一旦job执行结果变为可用了，每返回一个结果，result(ComputeJobResult, List)方法会被调用一次。该方法返回的策略将决定任务对每个作业结果的反应:    ①如果返回的策略是ComputeJobResultPolicy#WAIT，任务将继续等待其他的返回结果，毕竟还没执行完嘛。如果这个结果是最后一个工作结果，那么reduce(List)将会被调用了。    ②如果返回的策略是ComputeJobResultPolicy#REDUCE，那么reduce(List)将不等待其他工作完成的情况，立即被调用（所有剩下的工作将收到一个取消请求）。    ③如果返回的策略是ComputeJobResultPolicy#FAILOVER，那么job就会失败，到另一个节点去执行（就是故障转移）。作业的故障转移的节点节点由FailoverSpi决定的。注意，如果你是用ComputeTaskAdapter作为ComputeTask的实现，它会自动地将作业故障转移到另一个节点上，以完成两个已知的故障案例:    第一个故障：作业因节点崩溃而失败。在这个情况下，ComputeJobResult#getException()方法会返回org.apache.ignite.cluster.ClusterTopologyException的实例。    第二个故障：作业执行被拒绝，远程节点在有机会执行之前已经取消了作业，而它仍然在等待列表中。在这种情况下，ComputeJobResult#getException()会返回ComputeExecutionRejectedException异常实例。8.一旦所有的作业结果都接收了或者result(ComputeJobResult, List)返回了ComputeJobResultPolicy#REDUCE策略，reduce(List)方法将会被执行，他的作用是将所有的结果聚合为一个最终的结果。一旦该方法完成，网格任务的执行就完成了。你可以使用omputeTaskFuture#get()方法获取到结果。<持久的作业映射>当分开的作业太大的时候，不能同时在内存中使用，或者map(List, Object)这一步时候无法简单的知道所有的在任务中的作业。使用ComputeTaskContinuousMapper来持续地从任务中流中取作业，甚至map(...)结束了以后也是可以做到的。在这种情况下，结合@ComputeTaskNoResultCache注解一起使用就是有意义的。<任务结果缓存>有时工作结果太大，或者任务太多，无法跟踪哪些工作可能会影响性能。在这种情况下，绑定@ComputeTaskNoResultCache注解到task任务类上，禁用任务结果缓存可能是有意义的，并处理进入result(ComputeJobResult, List)方法的所有的作业集合。当ignite看到这个注解的时候，它会禁止跟踪工作结果，并列出所有传递到result(ComputeJobResult, List)的作业结果或者reduce(List)方法一直是空的。在计算任务会话中，作业的兄弟作业的列表也将是空的，以防止同级兄弟作业数量的增加。<资源注入>网格任务实现可以使用IoC进行注入，同样支持属性注入和方法注入，下面的会被注入的：    1.org.apache.ignite.resources.TaskSessionResource    2.org.apache.ignite.resources.IgniteInstanceResource    3.org.apache.ignite.resources.LoggerResource    4.org.apache.ignite.resources.SpringApplicationContextResource    5.org.apache.ignite.resources.SpringResource<网格任务适配器>ComputeTask附带几个便利的适配器，使使用更容易:    1.ComputeTaskAdapter为ComputeTask#result(ComputeJobResult, List)提供故障转移的默认实现。    这里有一个示例，说明如何使用ComputeTaskAdapter实现任务

public class MyFooBarTask extends ComputeTaskAdapter<String, String>{    // Inject load balancer.    ComputeLoadBalancer balancer;    // Map jobs to grid nodes.    public Map<? extends ComputeJob, ClusterNode> map(List<ClusterNode> subgrid, String arg) throws IgniteCheckedException {        Map<MyFooBarJob, ClusterNode> jobs = new HashMap<MyFooBarJob, ClusterNode>(subgrid.size());        // In more complex cases, you can actually do        // more complicated assignments of jobs to nodes.        for (int i = 0; i &lt; subgrid.size(); i++) {            // Pick the next best balanced node for the job.            jobs.put(new MyFooBarJob(arg), balancer.getBalancedNode())        }        return jobs;    }    // Aggregate results into one compound result.    public String reduce(List<ComputeJobResult> results) throws IgniteCheckedException {        // For the purpose of this example we simply        // job result        StringBuilder buf = new StringBuilder();        for (ComputeJobResult res : results) {            // Append string representation of result            // returned by every job.            buf.append(res.getData().string());        }        return buf.string();    }}

    2.ComputeTaskSplitAdapter隐藏了job-to-node映射逻辑，提供了方便的ComputeTaskSplitAdapter#split(int, Object)方法，来将任务分隔为在均匀的环境中的单个的作业。这里有一个示例，说明如何使用ComputeTaskSplitAdapter实现任务

public class MyFooBarTask extends ComputeTaskSplitAdapter<Object, String> {    @Override    protected Collection<? extends ComputeJob> split(int gridSize, Object arg) throws IgniteCheckedException {        List<MyFooBarJob> jobs = new ArrayList<MyFooBarJob>(gridSize);        for (int i = 0; i &lt; gridSize; i++) {            jobs.add(new MyFooBarJob(arg));        }        // Node assignment via load balancer        // happens automatically.        return jobs;    }    // Aggregate results into one compound result.    public String reduce(List<ComputeJobResult> results) throws IgniteCheckedException {        // For the purpose of this example we simply        // concatenate string representation of every        // job result        StringBuilder buf = new StringBuilder();        for (ComputeJobResult res : results) {            // Append string representation of result            // returned by every job.            buf.append(res.getData().string());        }        return buf.string();    }}

8.2 方法

8.2.1 public Map

8.2.2 public ComputeJobResultPolicy result(ComputeJobResult res, List<\ComputeJobResult> rcvd) throws IgniteException;

远程作业执行结果的返回，每一次返回，都会将次方法调用。该方法是异步的。该方法基于是否还要等到其他的作业结果集，来最终返回一个策略对象。减少到目前为止收到的结果，或者进行故障转移。ComputeJobResultPolicy这个类会介绍很多策略的信息。参数：    ComputeJobResult res：收到的远程网格可执行结果    List<ComputeJobResult> rcvd：所有之前收到结果。注意，如果task对象的类被@ComputeTaskNoResultCache注解注释了，那么这个list就是空的，这就是传说中的结果集缓存。返回值：    ComputeJobResultPolicy：结果策略决定了如何处理后续的工作结果。异常：    IgniteException：如果处理工作结果导致了错误

8.2.3 public R reduce(List<\ComputeJobResult> results) throws IgniteException;

将到目前为止所有的结果进行聚合，获取一个混合的结果，并在ComputeTaskFuture#get()方法调用下回执结果。请注意，如果某些作业没有成功，并且不能故障转移，那么将结果传递给该方法的列表将包括失败的结果。其他情况下，错误的结果集是不会进到这里的。参数：    List<ComputeJobResult> results：收到了广播远程执行的结果。注意，如果任务的类被@ComputeTaskNoResultCache注解了，那么这个列表就是空的返回值：通过远程执行的结果构建网格作业结果异常：IgniteException

9. IgnitionListener（接口：该接口继承自java.util.EventListener）

9.1 概述

用于gird状态更改通知的侦听器。可以再工厂中使用Ignition#addListener(IgnitionListener)方法来注册监听器。

9.2 方法

9.2.1 public void onStateChange(@Nullable String name, IgniteState state);

用于网格工厂状态更改通知的侦听器参数：    String name：ignite实例名,默认名字是null    IgniteState state：状态注意：该类没有实现类，都是以匿名实现类进行传递的。

10.IgniteState（Enum）

10.1 概述

org.apache.ignite.Ignition的可能状态的。你可以通过org.apache.ignite.Ignition#addListener(IgnitionListener)方法注册一个监听器来管理状态更改通知。

10.2 属性

//网格工厂开始的STARTED,//网格工厂停止STOPPED,//网格工厂由于网络分割问题而停止,这个状态的通知将只在策略时被触发STOPPED_ON_SEGMENTATION;//Enumerated valuesprivate static final IgniteState[] VALS = values();

10.3 方法

10.3.1 public static IgniteState fromOrdinal(byte ord)

     public static IgniteState fromOrdinal(byte ord) {           return ord >= 0 && ord < VALS.length ? VALS[ord] : null;     }

有效地从它的序数中得到枚举值

11.ClusterGroup（接口）

11.1 概述

定义一个包含所有集群节点或者集群的某几个子节点而组成的一个集群组。IgniteCluster接口也继承自ClusterGroup.
< IgniteCluster>
机群组允许你将集群节点分组成各种各样的子组，来在它们之上进行分布式的操作。所有的forXXX()方法会从已存在的集群组中创建一个子集群组。如果你从当前的集群组创建了一个新的集群组，那么新的集群组会包含当前集群组的子节点。如下的代码表示的是如何创建一个集群组：

Ignite ignite = Ignition.ignite();IgniteCluster cluster = ignite.cluster();// Cluster group over remote nodesClusterGroup remoteNodes = cluster.forRemotes();// Cluster group over random remote node.ClusterGroup randomNode = remoteNodes.forRandom();// Cluster group over all nodes with cache named "myCache" enabled.ClusterGroup cacheNodes = cluster.forCacheNodes("myCache");// Cluster group over all nodes that have the user attribute "group" set to the value "worker".ClusterGroup workerNodes = cluster.forAttribute("group", "worker");

11.2 方法

11.2.1 public Ignite ignite();

获取一个网格的实例返回值：    Ignite：它是所有API的主入口点

11.2.2 public ClusterGroup forNodes( Collection< ? extends ClusterNode> nodes);

在给定的节点集上创建集群组参数：    Collection<? extends ClusterNode> nodes：创建集群组的节点集合。返回值:    ClusterGroup:由提供的网格节点生成的集群组

11.2.3 public ClusterGroup forNode(ClusterNode node, ClusterNode… nodes);

为给定的节点创建一个集群组。参数：    ClusterNode node：创建集群组的节点    ClusterNode... nodes：包括到集群组中的可选的附加节点。返回值：    ClusterGroup：为了给定的节点的集群组

11.2.4 public ClusterGroup forOthers(ClusterNode node, ClusterNode… nodes);

为不包含给定节点的节点创建一个集群组参数：    ClusterNode node：排除在待新建的集群组的节点。    ClusterNode... nodes：排除在待新建的集群组之外的可选的附加节点返回值：    ClusterGroup：集群组将包含来自原始集群组的所有节点，不包括给定节点。、

11.2.5 public ClusterGroup forOthers(ClusterGroup prj);

为不包含在给定集群组中的节点创建一个集群组参数：    ClusterGroup prj：我们想排除在外的集群组返回值：    ClusterGroup：不包含在给定集群组中的节点的集群组

11.2.6 public ClusterGroup forNodeIds(Collection< UUID> ids);

用指定的节点id创建一个集群组参数：    Collection<UUID> ids：节点的集合id返回值：    ClusterGroup：使用指定的节点id对节点进行分组

11.2.7 public ClusterGroup forNodeId(UUID id, UUID… ids);

为具有指定ID的节点创建集群组。参数：    UUID id：用于获取集群组的节点ID    UUID... ids：可选的附加节点id，包括到集群组中返回值：    ClusterGroup：使用指定的节点id对节点进行分组

11.2.8 public ClusterGroup forPredicate(IgnitePredicate p);

创建一个新的集群组，其中包含传递给定谓词过滤器的所有节点参数：    IgnitePredicate<ClusterNode> p：对节点进行过滤的谓词过滤器返回值：    ClusterGroup：满足为此过滤器条件的节点所组成的集群组

11.2.9 public ClusterGroup forAttribute(String name, @Nullable Object val);

用户指定节点的属性名个属性值，系统会将满足这些属性的节点放进一个结果集群组中。每个节点的用户属性都是可选的，可以在网格节点配置中指定，可以去看IgniteConfiguration#getUserAttributes()这个方法，该方法查看用户为节点所设置的属性值以及默认属性。参数：    String name：属性的名称。    Object val：可选的需要匹配的属性值返回值：    ClusterGroup：包含指定属性的节点的集群组

11.2.10 public ClusterGroup forServers();

创建在服务器模式下启动的节点的集群组。参考：    Ignition#setClientMode(boolean)    IgniteConfiguration#setClientMode(boolean)返回值：    ClusterGroup：服务器模式启动后的节点的集群组

11.2.11 public ClusterGroup forClients();

创建在服务器模式下启动的节点的集群组。参考：    Ignition#setClientMode(boolean)    IgniteConfiguration#setClientMode(boolean)返回值：    ClusterGroup：客户端模式启动后的节点的集群组

11.2.12 public ClusterGroup forCacheNodes(String cacheName);

为所有具有指定名称的Cache的节点创建集群组。不管是以客户端还是服务端启动的。参数：    String cacheName：缓存名称返回值：    ClusterGroup：所有具有指定名称的Cache的节点创建集群组

11.2.13 public ClusterGroup forDataNodes(String cacheName);

为所有具有指定名称运行的缓存的数据节点创建集群组。参数：    String cacheName：缓存名称返回值：    ClusterGroup：所有具有指定名称运行的缓存的数据节点创建集群组

11.2.14 public ClusterGroup forClientNodes(String cacheName);

为所有使用指定名称访问缓存的客户节点创建集群组。参数：    String cacheName：缓存名称返回值：    ClusterGroup：所有使用指定名称访问缓存的客户节点创建集群组

11.2.15 public ClusterGroup forRemotes();

从这个集群组中的节点组成集群组，不包括本地节点。返回值：    ClusterGroup：由这个集群组中的节点组成的集群组，不包括本地节点。

11.2.16 public ClusterGroup forHost(ClusterNode node);

从这个集群组中的节点组成的集群组，与给定的节点驻留在同一主机上。参数：    ClusterNode node：为选择主机而存在的节点对象返回值：    ClusterGroup：与指定的节点驻留在同一台主机上的节点的集群组

11.2.17 public ClusterGroup forHost(String host, String… hosts);

获取到运行在指定的主机上的节点的集群组参数：    String host：可以放进集群中的节点所处的主机    String... hosts：可以放进集群中的节点所处的主机名返回值：    ClusterGroup：运行在指定的主机上的节点的集群组

11.2.18 public ClusterGroup forDaemons();

获取由守护进程节点组成的集群组守护程序节点是参与拓扑的常见网格节点，但是不会在主api上可见。它们不是任何集群组的一部分，这个方法是唯一的方式来查看这些守护节点。守护节点一般是用于需要参与到拓扑中并且构建在ignite上的管理和监控功能，但是需要排除在“正常”的拓扑之外，所以它不会参与任务执行活着内存数据网格存储。返回值：    ClusterGroup：由守护进程节点组成的集群组

11.2.19 public ClusterGroup forRandom();

创建一个当前集群组中随机节点组成的集群组返回值：    ClusterGroup：当前集群组中随机节点组成的集群组

11.2.20 public ClusterGroup forOldest();

用当前集群组中的最早创建的节点生成的集群组。产生的集群组是动态的，如果在创建了集群组之后，即使前一个节点离开了拓扑，也总是会自动的再选择下一个最老的节点。使用node()来获取最早创建的节点返回值：    ClusterGroup：当前集群组中的最早创建的节点生成的集群组。

11.2.21 public ClusterGroup forYoungest();

用当前集群组中的最新创建的节点生成的集群组。产生的集群组是动态的，如果在创建了集群组之后，即使前一个节点离开了拓扑，也总是会自动的再选择下一个最新的节点。返回值：    ClusterGroup：当前集群组中的最新创建的节点生成的集群组。

11.2.22 public Collection< ClusterNode> nodes();

获取这个集群组中的节点的集合返回值：    Collection<ClusterNode>：集群组中的所有节点

11.2.23 public ClusterNode node(UUID nid);

从这个集群组获取给定ID的节点参数：    UUID nid：节点的ID返回值：    ClusterNode：根据节点ID返回该节点，如果没有则返回null。

11.2.24 public ClusterNode node();

从这个集群组的节点列表中获取第一个节点，这个方法对于只有一个节点的集群组非常有用。返回值：    ClusterNode：这个集群组的节点列表中获取第一个节点，如果没有就返回null。

11.2.25 public Collection hostNames();

获取这个集群组中的主机名的只读的集合返回值：    Collection<String>：这个集群组中的所有主机名

11.2.26 public IgnitePredicate< ClusterNode> predicate();

为这个集群组定义一个节点子集的谓词。返回值：    为这个集群组定义节点子集的谓词。

11.2.7 public ClusterMetrics metrics() throws IgniteException;

获取这个集群组的度量信息快照返回值：    快照

12 Ignite（接口）

12.1 概述

所有ignite api的主入口点。你可以使用Ignition.ignite()方法来获取一个Ignite实例，或者使用Ignition.ignite(String name)来获取一个命名了的网格。通过给每个实例一个不同的名称，可以在同一个VM中运行多个实例。Ignite提供以下功能:>IgniteCluster:集群功能>IgniteCache:内存中分布式缓存的功能,baokuo SQL,TEXT,Predicate-based查询>IgniteTransactions:符合acid的分布事务>IgniteDataStreamer:将大量数据流到缓存中的功能>IgniteCompute:在所有网格节点(继承自ClusterGroup)上执行任务和闭包的功能>IgniteServices:分布式服务网格功能(在集群中是单例的)>IgniteMessaging:所有网格节点(继承自ClusterGroup)上的基于主题的消息交换的功能>IgniteEvents:查询和监听所有网格节点(继承自ClusterGroup)上的事件的功能>ExecutorService:分布式的线程池>IgniteAtomicLong:：分布式原子long>IgniteAtomicReference:分布式原子引用reference>IgniteAtomicSequence:分布式原子序列>IgniteAtomicStamped:分布式原子有标记的引用reference>IgniteCountDownLatch:分布式countLatchDowm>IgniteQueue:分布式阻塞队列>IgniteSet:分布式并发集合>IgniteScheduler:使用UNIX Cron语法调度作业的功能>IgniteFileSystem:分布式hadoop兼容的内存文件系统和map - reduce的功能。

12.2 方法

12.2.1 public String name();

获取ignite实例的名称。通过给每个实例一个不同的名称，可以在同一个VM中运行多个实例。如果使用默认的ignite实例,那么就返回null参考Ignition文档中的如何开始你所命名的ignite实例。返回值：    String：ignite实例的名字。如果使用默认的ignite实例,那么就返回null

12.2.2 public IgniteLogger log();

获取网格的记录日志返回值：    IgniteLogger ：日志

12.2.3 public IgniteConfiguration configuration();

获取这个ignite实例的配置。注意：    通过这种方法获得的SPIs不应该被直接使用。SPIs提供了子系统的内部视图，并且在内部使用ignite内核。比较少使用的场景是，当需要访问这个SPI的特定实现时--这个SPI实例的可以通过这个方法来检查他的配置信息或者调用其他的non-spi返回值：    IgniteConfiguration：ignite配置实例

12.2.4 public IgniteCluster cluster();

获取IgniteCluster接口的实例。返回值：    IgniteCluster：IgniteCluster接口的实例

12.2.5 public IgniteCompute compute();

在所有的以服务器模式启动的集群节点上的compute的外观模式返回值：    IgniteCompute：以服务器模式启动的集群节点的计算实例

12.2.6 public IgniteCompute compute(ClusterGroup grp);

获取指定的集群组上的计算的外观。所有的在这个方法返回值（及IgniteCompute）的实例上的操作将会只包含该集群组上的节点。参数：    ClusterGroup grp：集群组返回值：    IgniteCompute：对给定集群组的计算实例

12.2.7 public IgniteMessaging message();

获取对所有集群节点的消息传递实例。返回值：    IgniteMessaging：对所有集群节点的消息传递实例

12.2.8 public IgniteMessaging message(ClusterGroup grp);

在给定的集群组内，获取消息传递的外观对象。所有的在该方法返回的IgniteMessaging实例上的操作将会只包含该集群组上的节点。参数：    ClusterGroup grp：集群组返回值：    IgniteMessaging：集群节点的消息传递实例

12.2.9 public IgniteEvents events();

获取在所有的集群节点上的事件外观对象。返回值：    IgniteEvents：所有集群节点上的事件实例

12.2.10 public IgniteEvents events(ClusterGroup grp);

在给定的集群组中获取事件的外观对象。所有的在该方法返回的IgniteEvents上进行的操作都会仅仅包含该集群组上的节点。参数：    ClusterGroup grp：集群组返回值：    IgniteEvents：集群节点上的事件实例

12.2.11 public IgniteServices services();

获取所有以服务器端模式启动的节点的服务外观对象。返回值：    IgniteServices：以服务器端模式启动的节点的服务外观对象

12.2.12 public IgniteServices services(ClusterGroup grp);

获取在给定的集群组中的服务外观对象。所有的在该方法返回值IgniteMessaging实例上的操作将会仅仅包含该集群组上的节点。参数：    ClusterGroup grp：集群组返回值：    IgniteServices：以服务器端模式启动的节点的服务外观对象

12.2.13 public ExecutorService executorService();

创建一个新的ExecutorService对象，这个对象可以处理所有集群节点提交的Callable和Runnable任务。这个方法本质上创建了一个分布式线程池，他可以被用来取代本地线程池。返回值：    ExecutorService：ExecutorService对象

12.2.14 public ExecutorService executorService(ClusterGroup grp);

创建一个新的ExecutorService对象，这个对象可以处理所有在指定集群组中的节点提交的Callable和Runnable任务。这个方法本质上创建了一个分布式线程池，他可以被用来取代本地线程池。参数：    ClusterGroup grp：集群组返回值：    ExecutorService：可以再给定的集群组的节点上执行任务的ExecutorService对象

12.2.15 public IgniteProductVersion version();

ignite版本

12.2.16 public IgniteScheduler scheduler();

获取一个基于cron表达式的调度实例返回值：    IgniteScheduler ：调度实例

12.2.17 public

12.2.18 public Collection< IgniteCache> createCaches(Collection cacheCfgs) throws CacheException;

根据传入的配置信息启动缓存组如果本地节点是一个关联节点，该方法将返回一个启动的缓存实例。其他情况下，它会在本地节点创建一个客户端cache。如果在该网格中已经有了这个命名的cache存在了，那么就会抛出异常，不管配置是否全部一致与不一致。参数：    Collection<CacheConfiguration> cacheCfgs：缓存配合信息的集合返回值：    Collection<IgniteCache>：缓存实例的集合

12.2.19 public < K, V> IgniteCache< K, V> createCache(String cacheName) throws CacheException;

使用模板配置动态启动新缓存。如果本地节点是一个关联节点，该方法将返回一个启动的缓存实例。其他情况下，它会在本地节点创建一个客户端cache。如果在该网格中已经有了这个命名的cache存在了，那么就会抛出异常，不管配置是否全部一致与不一致。   参数：    String cacheName：缓存的名字返回值：    IgniteCache：启动的缓存实例

12.2.20 public

12.2.21 public

12.2.22 public Collection< IgniteCache> getOrCreateCaches(Collection< CacheConfiguration> cacheCfgs) throws CacheException;

根据传入的名字，查找相应的缓存实例。如果实例不存在，那么就是用传入的配置创建一个新的缓存实例如果重名的缓存已经存在了，那么不会检查配置信息，直接返回。参数：    Collection< CacheConfiguration>  cacheCfgs：缓存配置集合返回值：     Collection< IgniteCache>：缓存实例集合

12.2.23 public < K, V> void addCacheConfiguration(CacheConfiguration< K, V> cacheCfg) throws CacheException;

增加缓存配置参数：    CacheConfiguration<K, V> cacheCfg：缓存配置模板

12.2.24 public < K, V> IgniteCache< K, V> createCache(CacheConfiguration< K, V> cacheCfg,NearCacheConfiguration< K, V> nearCfg) throws CacheException;

根据给的配置信息启动新的缓存。如果本地节点是一个关联节点，该方法将返回一个启动的缓存实例。其他情况下，它会在本地节点创建一个客户端cache。如果在该网格中已经有了这个命名的cache存在了，那么就会抛出异常，不管配置是否全部一致与不一致。   参数：    CacheConfiguration<K, V> cacheCfg：缓存配置    NearCacheConfiguration<K, V> nearCfg：如果节点不是关联节点，那么我们就要创建新的缓存了，这个对象就是给本地节点用的返回值：    IgniteCache：启动的缓存实例

12.2.25 public < K, V> IgniteCache< K, V> getOrCreateCache(CacheConfiguration< K, V> cacheCfg, NearCacheConfiguration< K, V> nearCfg) throws CacheException;

使用给定的缓存配置获取现有缓存，如果不存在就创建一个。如果在该网格中已经有了这个命名的cache存在了，那么就会抛出异常，不管配置是否全部一致与不一致。   如果本地节点不是一个关联节点，没有nearCache的客户端缓存已经启动了的话，将会抛出异常。参数：    CacheConfiguration<K, V> cacheCfg：缓存配置    NearCacheConfiguration<K, V> nearCfg：为客户端缓存配置（near Cache的意思就是客户端缓存）返回值：    IgniteCache：缓存实例

12.2.26 public < K, V> IgniteCache< K, V> createNearCache(String cacheName, NearCacheConfiguration< K, V> nearCfg) throws CacheException;

如果缓存先前以createCache(CacheConfiguration)或者createCache(CacheConfiguration, NearCacheConfiguration)方法启动过，那么就在本地节点启动一个客户端缓存。参数：    String cacheName：缓存的名字    NearCacheConfiguration<K, V> nearCfg：客户端缓存配置返回值：    IgniteCache：缓存实例

12.2.27 public < K, V> IgniteCache< K, V> getOrCreateNearCache(String cacheName, NearCacheConfiguration< K, V> nearCfg) throws CacheException;

使用指定的缓存名称，来获取存在的客户端缓存，或者创建一个新的缓存。参数：    String cacheName：缓存名称    NearCacheConfiguration<K, V> nearCfg：客户端缓存配置返回值：    IgniteCache：缓存实例

12.2.28 public void destroyCache(String cacheName) throws CacheException;

动态关闭启动了的缓存参数：    String cacheName：缓存名字

12.2.29 public void destroyCaches(Collection cacheNames) throws CacheException;

动态关闭启动了的缓存参数：    Collection<String> cacheNamescacheName：缓存名字的集合

12.2.30 public

12.2.31 public Collection< String> cacheNames();

获取当前可用缓存的名称集合集合中可能有null,因为默认的缓存名字就是null

12.2.32 public IgniteTransactions transactions();

获取网格事务的外观对象返回值：    IgniteTransactions：网格事务外观对象

12.2.33 public

12.2.34 public IgniteFileSystem fileSystem(String name) throws IllegalArgumentException;

获取一个IGFS（Ignite In-Memory File System）实例。如果有一个没有被配置，那么就抛出异常。IGFS完全符合hadoop文件系统的API，可以被连接到hadoop产品中。更多信息，查看“Hadoop integration shipped with Ignite”参数：    String name：IGFS名字返回值：    IgniteFileSystem：IGFS实例

12.2.35 public Collection fileSystems();

获取所有的IGFS（Ignite In-Memory File System）实例。

12.2.36 public IgniteAtomicSequence atomicSequence(String name, long initVal, boolean create) throws IgniteException;

从缓存中取出指定名字的原子的序列，如果指定的序列，并且第二个参数flag是true，那么会创建一个新的原子序列。参数：    String name：序列名字、    long initVal：序列的初始值。如果create标示位是false，那么会忽视掉它    boolean create：当原子序列不存在，是否要进行新建返回值：    IgniteAtomicSequence：根据给定名字返回的原子序列

12.2.37 public IgniteAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteException;

从缓存中取出指定名字的原子的long，如果指定的序列，并且第二个参数flag是true，那么会创建一个新的原子long。

12.2.38 public IgniteAtomicReference atomicReference(String name, @Nullable T initVal, boolean create) throws IgniteException;

从缓存中取出指定名字的原子的reference，如果指定的序列，并且第二个参数flag是true，那么会创建一个新的原子reference。

12.2.39 public <\T, S> IgniteAtomicStamped<\T, S> atomicStamped(String name, @Nullable \T initVal, @Nullable S initStamp, boolean create) throws IgniteException;\

从缓存中取出指定名字的原子的stamped，如果指定的序列，并且第二个参数flag是true，那么会创建一个新的原子stamped。

12.2.40 public IgniteCountDownLatch countDownLatch(String name, int cnt, boolean autoDel, boolean create) throws IgniteException;

从缓存中取出指定名字的countDownLatch，如果指定的序列，并且第二个参数flag是true，那么会创建一个新的countDownLatch。

12.2.41 public IgniteSemaphore semaphore(String name, int cnt, boolean failoverSafe, boolean create) throws IgniteException;

获取或者新建一个信号量。如果在缓存中没有发现该指定名字的信号量，那么如果create参数是true情况下，会新建一个信号量。参数：    String name：信号量的名字    int cnt：新创建的信号量的count。如果create属性shifalse,那么该属性会被忽视    boolean failoverSafe：如果是true，那么会创建fail-over(失效备援)的线程安全的信号量，这意味着如果任何节点离开该节点已经获得的拓扑许可，就会被悄悄地释放，并可用于活着的节点获取。如果是false,所有线程都等待可用的许可被打断。    boolean create：表示不存在的数据结构是否应该创建的布尔标志返回值：    IgniteSemaphore：指定的名字的信号量

12.2.41 public IgniteLock reentrantLock(String name, boolean failoverSafe, boolean fair, boolean create) throws IgniteException;

从缓存中取出指定名字的可重进的锁（ReentrantLock），如果指定的锁不存在，并且created参数flag是true，那么会创建一个新的可重进的锁（ReentrantLock）。参数：    String name：锁的名字    boolean failoverSafe：如果是true，创建故障转移的安全的可重进的锁（ReentrantLock），这意味着任何节点离开拓扑，该节点已获得的所有锁都已被悄悄地释放，并可用于其他节点获取。如果该标识是false,那么在其他节点上的所有的等待获取锁的线程都会被中断。    boolean fair： 入股佛是true，那么会创建公平的锁    boolean create：表示不存在的数据结构是否应该创建的布尔标志。返回值：    IgniteLock：指定名字的可重入 锁

12.2.42 public < T> IgniteQueue< T> queue(String name, int cap, @Nullable CollectionConfiguration cfg) throws IgniteException;

从缓存中取出指定名字的queue队列，如果指定的锁不存在，并且created参数flag是true，那么会创建一个新的queue队列。如果队列已经存在，队列属性不会更改。如果你又很多相对较小的队列，配置使用CacheMode#PARTITIONED缓存，因为它可以更快地进行抓取、查询和迭代。如果你又几个相对比较大的队列，那么你应该考虑关闭配置，因为它们可能不适合单个节点的内存参数：    String name：队列的名字    int cap：对垒初始化的大小，如果第三个参数的配置信息是null，那么这个参数也会被忽略    CollectionConfiguration cfg：如果应该创建新的队列的队列配置返回值：    IgniteQueue：给定的属性匹配的队列

12.2.43 public IgniteSet set(String name, @Nullable CollectionConfiguration cfg) throws IgniteException;

从缓存中取出指定名字的set列表，如果指定的锁不存在，并且created参数flag是true，那么会创建一个新的set列表。

12.2.44 public < T extends IgnitePlugin> T plugin(String name) throws PluginNotFoundException;

获取一个已部署的ignite插件的实例。参数：    String name：插件名字返回值：    IgnitePlugin：插件

12.2.45 public IgniteBinary binary();

返回IgniteBinary接口实例

12.2.46 public void close() throws IgniteException;

关闭网格实例。这个方法与G.stop(igniteInstanceName, true)是一样的。该方法在由对象管理的对象上自动调用try-with-resources。

12.2.47 public < K> Affinity< K> affinity(String cacheName);

获取关联服务，提供关于数据分区和分布的信息

12.2.48 public boolean active();

检查启动网格是活动的还是不活跃的

12.2.49 public void active(boolean active);

更改使网格状态激活或不活动

12.2.50 public void resetLostPartitions(Collection cacheNames);

清除分区丢失的状态，将缓存移动到正常模式

12.2.51 public Collection memoryMetrics();

返回一个在这个Apache ignite节点实例上反映页面内存使用情况的MemoryMetrics的列表，

Database Instance Apache Ignite server
Table Cache
Row Key-value
RowID Key