| Package | Description |
|---|---|
| org.apache.ignite |
Contains entry-point Ignite & HPC APIs.
|
| org.apache.ignite.cluster |
Contains cluster-related classes.
|
| org.apache.ignite.compute |
Contains Compute Grid functionality.
|
| org.apache.ignite.lang |
Contains general language constructs and functional APIs for distributed computations.
|
| org.apache.ignite.scheduler |
Contains Job Scheduling functionality.
|
| org.apache.ignite.spi |
Contains common classes and interfaces for SPI implementations.
|
| org.apache.ignite.spi.communication.tcp |
Contains default TCP/IP-based implementation for communication SPI.
|
| org.apache.ignite.spi.discovery |
Contains APIs for topology manager SPI.
|
| org.apache.ignite.transactions |
Contains transaction-related classes.
|
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteFuture<T> |
IgniteSemaphore.acquireAndExecute(IgniteCallable<T> callable,
int numPermits)
Acquires the given semaphore, executes the given callable and schedules the release of permits asynchronously
|
IgniteFuture<?> |
IgniteDataStreamer.addData(Collection<? extends Map.Entry<K,V>> entries)
Adds data for streaming on remote node.
|
IgniteFuture<?> |
IgniteDataStreamer.addData(K key,
V val)
Adds data for streaming on remote node.
|
IgniteFuture<?> |
IgniteDataStreamer.addData(Map.Entry<K,V> entry)
Adds data for streaming on remote node.
|
IgniteFuture<?> |
IgniteDataStreamer.addData(Map<K,V> entries)
Adds data for streaming on remote node.
|
<R> IgniteFuture<R> |
IgniteCompute.affinityCallAsync(@NotNull Collection<String> cacheNames,
int partId,
IgniteCallable<R> job)
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.
|
<R> IgniteFuture<R> |
IgniteCompute.affinityCallAsync(@NotNull Collection<String> cacheNames,
Object affKey,
IgniteCallable<R> job)
Executes given job asynchronously on the node where data for provided affinity key is located
(a.k.a. affinity co-location).
|
<R> IgniteFuture<R> |
IgniteCompute.affinityCallAsync(String cacheName,
Object affKey,
IgniteCallable<R> job)
Executes given job asynchronously on the node where data for provided affinity key is located
(a.k.a. affinity co-location).
|
IgniteFuture<Void> |
IgniteCompute.affinityRunAsync(@NotNull Collection<String> cacheNames,
int partId,
IgniteRunnable job)
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.
|
IgniteFuture<Void> |
IgniteCompute.affinityRunAsync(@NotNull Collection<String> cacheNames,
Object affKey,
IgniteRunnable job)
Executes given job asynchronously on the node where data for provided affinity key is located
(a.k.a. affinity co-location).
|
IgniteFuture<Void> |
IgniteCompute.affinityRunAsync(String cacheName,
Object affKey,
IgniteRunnable job)
Executes given job asynchronously on the node where data for provided affinity key is located
(a.k.a. affinity co-location).
|
<T,R> IgniteFuture<Collection<R>> |
IgniteCompute.applyAsync(IgniteClosure<T,R> job,
Collection<? extends T> args)
Executes provided closure job asynchronously on nodes within the underlying cluster group.
|
<R,T> IgniteFuture<R> |
IgniteCompute.applyAsync(IgniteClosure<T,R> job,
T arg)
Executes provided closure job asynchronously on a node within the underlying cluster group.
|
<R1,R2,T> IgniteFuture<R2> |
IgniteCompute.applyAsync(IgniteClosure<T,R1> job,
Collection<? extends T> args,
IgniteReducer<R1,R2> rdc)
Executes provided closure job asynchronously on nodes within the underlying cluster group.
|
<R> IgniteFuture<Collection<R>> |
IgniteCompute.broadcastAsync(IgniteCallable<R> job)
Broadcasts given job asynchronously to all nodes in cluster group.
|
<R,T> IgniteFuture<Collection<R>> |
IgniteCompute.broadcastAsync(IgniteClosure<T,R> job,
T arg)
Broadcasts given closure job asynchronously with passed in argument to all nodes in the cluster group.
|
IgniteFuture<Void> |
IgniteCompute.broadcastAsync(IgniteRunnable job)
Broadcasts given job asynchronously to all nodes in the cluster group.
|
<R> IgniteFuture<Collection<R>> |
IgniteCompute.callAsync(Collection<? extends IgniteCallable<R>> jobs)
Executes collection of jobs asynchronously on nodes within the underlying cluster group.
|
<R1,R2> IgniteFuture<R2> |
IgniteCompute.callAsync(Collection<? extends IgniteCallable<R1>> jobs,
IgniteReducer<R1,R2> rdc)
Executes collection of jobs asynchronously on nodes within the underlying cluster group.
|
<R> IgniteFuture<R> |
IgniteCompute.callAsync(IgniteCallable<R> job)
Executes provided job asynchronously on a node within the underlying cluster group.
|
<R> IgniteFuture<R> |
IgniteScheduler.callLocal(@NotNull Callable<R> c)
Executes given callable on internal system thread pool asynchronously.
|
IgniteFuture<Void> |
IgniteServices.cancelAllAsync()
Asynchronously cancels all deployed services.
|
IgniteFuture<Void> |
IgniteServices.cancelAllAsync(Collection<String> names)
Asynchronously cancels services with specified names.
|
IgniteFuture<Void> |
IgniteServices.cancelAsync(String name)
Asynchronously cancels service deployment.
|
IgniteFuture<Void> |
IgniteSnapshot.cancelSnapshot(String name)
Cancel running snapshot operation.
|
IgniteFuture<Boolean> |
IgniteSnapshot.cancelSnapshotRestore(String name)
Cancel snapshot restore operation.
|
IgniteFuture<Void> |
IgniteEncryption.changeCacheGroupKey(Collection<String> cacheOrGrpNames)
Starts cache group encryption key change process.
|
IgniteFuture<Void> |
IgniteEncryption.changeMasterKey(String masterKeyName)
Starts master key change process.
|
IgniteFuture<Void> |
IgniteCache.clearAllAsync(Set<? extends K> keys)
Asynchronously clears entries from the cache and swap storage, without notifying listeners or
CacheWriters. |
IgniteFuture<Void> |
IgniteCache.clearAsync()
Asynchronously clears the contents of the cache, without notifying listeners or
CacheWriters. |
IgniteFuture<Void> |
IgniteCache.clearAsync(K key)
Asynchronously clears entry from the cache and swap storage, without notifying listeners or
CacheWriters. |
@Nullable IgniteFuture<?> |
IgniteCluster.clientReconnectFuture()
If local client node disconnected from cluster returns future
that will be completed when client reconnected.
|
IgniteFuture<Boolean> |
IgniteCache.containsKeyAsync(K key)
Asynchronously determines if the
Cache contains an entry for the specified key. |
IgniteFuture<Boolean> |
IgniteCache.containsKeysAsync(Set<? extends K> keys)
Asynchronously determines if the
Cache contains entries for the specified keys. |
IgniteFuture<Void> |
IgniteSnapshot.createDump(String name,
@Nullable Collection<String> cacheGroupNames)
Creates cache groups dump.
|
IgniteFuture<Void> |
IgniteSnapshot.createIncrementalSnapshot(String snapshotName)
Create an incremental snapshot for an existing snapshot.
|
IgniteFuture<Void> |
IgniteSnapshot.createSnapshot(String name)
Create a consistent copy of all persistence cache groups from the whole cluster.
|
IgniteFuture<Void> |
IgniteServices.deployAllAsync(Collection<ServiceConfiguration> cfgs)
Asynchronously deploys multiple services described by provided configurations.
|
IgniteFuture<Void> |
IgniteServices.deployAsync(ServiceConfiguration cfg)
Asynchronously deploys multiple instances of the service on the grid according to provided
configuration.
|
IgniteFuture<Void> |
IgniteServices.deployClusterSingletonAsync(String name,
Service svc)
Asynchronously deploys a cluster-wide singleton service.
|
IgniteFuture<Void> |
IgniteServices.deployKeyAffinitySingletonAsync(String name,
Service svc,
@Nullable String cacheName,
Object affKey)
Asynchronously deploys one instance of this service on the primary node for a given affinity key.
|
IgniteFuture<Void> |
IgniteServices.deployMultipleAsync(String name,
Service svc,
int totalCnt,
int maxPerNodeCnt)
Asynchronously deploys multiple instances of the service on the grid.
|
IgniteFuture<Void> |
IgniteServices.deployNodeSingletonAsync(String name,
Service svc)
Asynchronously deploys a per-node singleton service.
|
IgniteFuture<?> |
IgniteDataStreamer.future()
Gets future for this streaming process.
|
IgniteFuture<Map<K,V>> |
IgniteCache.getAllAsync(Set<? extends K> keys)
Asynchronously gets a collection of entries from the
Cache, returning them as
Map of the values associated with the set of keys requested. |
IgniteFuture<Map<K,V>> |
IgniteCache.getAllOutTxAsync(Set<? extends K> keys)
Asynchronously gets values from cache.
|
IgniteFuture<V> |
IgniteCache.getAndPutAsync(K key,
V val)
Asynchronously associates the specified value with the specified key in this cache,
returning an existing value if one existed as the future result.
|
IgniteFuture<V> |
IgniteCache.getAndPutIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteFuture<V> |
IgniteCache.getAndRemoveAsync(K key)
Asynchronously removes the entry for a key only if currently mapped to some
value.
|
IgniteFuture<V> |
IgniteCache.getAndReplaceAsync(K key,
V val)
Asynchronously replaces the value for a given key if and only if there is a
value currently mapped by the key.
|
IgniteFuture<V> |
IgniteCache.getAsync(K key)
Asynchronously gets an entry from the cache.
|
IgniteFuture<Collection<CacheEntry<K,V>>> |
IgniteCache.getEntriesAsync(Set<? extends K> keys)
Asynchronously gets a collection of entries from the
Cache. |
IgniteFuture<CacheEntry<K,V>> |
IgniteCache.getEntryAsync(K key)
Asynchronously gets an entry from the cache.
|
IgniteFuture<?> |
IgniteCache.indexReadyFuture()
Returns future that will be completed when all indexes for this cache are ready to use.
|
<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
IgniteCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args)
Asynchronous version of the
IgniteCache.invokeAll(Map, Object...) method. |
<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
IgniteCache.invokeAllAsync(Set<? extends K> keys,
CacheEntryProcessor<K,V,T> entryProcessor,
Object... args)
Asynchronously invokes an
CacheEntryProcessor against the set of Cache.Entrys
specified by the set of keys. |
<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
IgniteCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args)
Asynchronously invokes an
EntryProcessor against the set of Cache.Entrys
specified by the set of keys. |
<T> IgniteFuture<T> |
IgniteCache.invokeAsync(K key,
CacheEntryProcessor<K,V,T> entryProcessor,
Object... arguments)
Asynchronously invokes an
CacheEntryProcessor against the Cache.Entry specified by
the provided key. |
<T> IgniteFuture<T> |
IgniteCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... arguments)
Asynchronously invokes an
EntryProcessor against the Cache.Entry specified by
the provided key. |
IgniteFuture<Void> |
IgniteCache.loadCacheAsync(@Nullable IgniteBiPredicate<K,V> p,
Object... args)
Asynchronously executes
IgniteCache.localLoadCache(IgniteBiPredicate, Object...) on all cache nodes. |
IgniteFuture<Void> |
IgniteCache.localLoadCacheAsync(@Nullable IgniteBiPredicate<K,V> p,
Object... args)
Asynchronously loads state from the underlying persistent storage by delegating
to
CacheStore.loadCache(IgniteBiInClosure,Object...) method. |
IgniteFuture<Void> |
IgniteCache.preloadPartitionAsync(int partition)
Efficiently preloads cache partition into page memory.
|
IgniteFuture<Void> |
IgniteCache.putAllAsync(Map<? extends K,? extends V> map)
Asynchronously copies all of the entries from the specified map to the
Cache. |
IgniteFuture<Void> |
IgniteCache.putAsync(K key,
V val)
Asynchronously associates the specified value with the specified key in the cache.
|
IgniteFuture<Boolean> |
IgniteCache.putIfAbsentAsync(K key,
V val)
Asynchronously associates the specified key with the given value if it is
not already associated with a value.
|
IgniteFuture<Boolean> |
IgniteCache.rebalance()
Deprecated.
Use baseline topology feature instead. Please, be aware this API will be removed in the next releases.
|
IgniteFuture<?> |
IgniteClientDisconnectedException.reconnectFuture() |
<T extends Event> |
IgniteEvents.remoteListenAsync(@Nullable IgniteBiPredicate<UUID,T> locLsnr,
@Nullable IgnitePredicate<T> rmtFilter,
int... types)
Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including
local node if it belongs to the cluster group as well).
|
<T extends Event> |
IgniteEvents.remoteListenAsync(int bufSize,
long interval,
boolean autoUnsubscribe,
@Nullable IgniteBiPredicate<UUID,T> locLsnr,
@Nullable IgnitePredicate<T> rmtFilter,
int... types)
Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including
local node if it belongs to the cluster group as well).
|
IgniteFuture<UUID> |
IgniteMessaging.remoteListenAsync(@Nullable Object topic,
IgniteBiPredicate<UUID,?> p)
Asynchronously adds a message listener for a given topic to all nodes in the cluster group (possibly including
this node if it belongs to the cluster group as well).
|
<T extends Event> |
IgniteEvents.remoteQueryAsync(IgnitePredicate<T> p,
long timeout,
int... types)
Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event
selection.
|
IgniteFuture<Void> |
IgniteCache.removeAllAsync()
Asynchronously removes all of the mappings from this cache.
|
IgniteFuture<Void> |
IgniteCache.removeAllAsync(Set<? extends K> keys)
Asynchronously removes entries for the specified keys.
|
IgniteFuture<Boolean> |
IgniteCache.removeAsync(K key)
Asynchronously removes the mapping for a key from this cache if it is present.
|
IgniteFuture<Boolean> |
IgniteCache.removeAsync(K key,
V oldVal)
Asynchronously removes the mapping for a key only if currently mapped to the
given value.
|
IgniteFuture<?> |
IgniteDataStreamer.removeData(K key)
Adds key for removal on remote node.
|
IgniteFuture<Boolean> |
IgniteCache.replaceAsync(K key,
V val)
Asynchronously replaces the entry for a key only if currently mapped to a
given value.
|
IgniteFuture<Boolean> |
IgniteCache.replaceAsync(K key,
V oldVal,
V newVal)
Asynchronous version of the
IgniteCache.replace(Object, Object, Object). |
IgniteFuture<?> |
IgniteCacheRestartingException.restartFuture() |
IgniteFuture<Void> |
IgniteSnapshot.restoreSnapshot(String name,
@Nullable Collection<String> cacheGroupNames)
Restore cache group(s) from the snapshot.
|
IgniteFuture<Void> |
IgniteSnapshot.restoreSnapshot(String name,
@Nullable Collection<String> cacheGroupNames,
int incIdx)
Restore cache group(s) from the snapshot and its increments.
|
IgniteFuture<Void> |
IgniteCompute.runAsync(Collection<? extends IgniteRunnable> jobs)
Executes collection of jobs asynchronously on grid nodes within the underlying cluster group.
|
IgniteFuture<Void> |
IgniteCompute.runAsync(IgniteRunnable job)
Executes provided job asynchronously on a node within the underlying cluster group.
|
IgniteFuture<?> |
IgniteScheduler.runLocal(@NotNull Runnable r)
Executes given closure on internal system thread pool asynchronously.
|
IgniteFuture<Integer> |
IgniteCache.sizeAsync(CachePeekMode... peekModes)
Asynchronously gets the number of all entries cached across all nodes.
|
IgniteFuture<Long> |
IgniteCache.sizeLongAsync(CachePeekMode... peekModes)
Asynchronously gets the number of all entries cached across all nodes as a long value.
|
IgniteFuture<Long> |
IgniteCache.sizeLongAsync(int partition,
CachePeekMode... peekModes)
Asynchronously gets the number of all entries cached in a partition as a long value.
|
IgniteFuture<Collection<ClusterStartNodeResult>> |
IgniteCluster.startNodesAsync(Collection<Map<String,Object>> hosts,
@Nullable Map<String,Object> dflts,
boolean restart,
int timeout,
int maxConn)
Starts one or more nodes on remote host(s) asynchronously.
|
IgniteFuture<Collection<ClusterStartNodeResult>> |
IgniteCluster.startNodesAsync(File file,
boolean restart,
int timeout,
int maxConn)
Starts one or more nodes on remote host(s) asynchronously.
|
IgniteFuture<Void> |
IgniteEvents.stopRemoteListenAsync(UUID opId)
Asynchronously stops listening to remote events.
|
IgniteFuture<Void> |
IgniteMessaging.stopRemoteListenAsync(UUID opId)
Asynchronously unregisters all listeners identified with provided operation ID on all nodes in the cluster group.
|
<T extends Event> |
IgniteEvents.waitForLocalAsync(@Nullable IgnitePredicate<T> filter,
int... types)
Create future to wait for the specified events.
|
| Constructor and Description |
|---|
IgniteCacheRestartingException(IgniteFuture<?> restartFut,
String cacheName) |
IgniteCacheRestartingException(IgniteFuture<?> restartFut,
String cacheName,
@Nullable Throwable cause) |
IgniteClientDisconnectedException(IgniteFuture<?> reconnectFut,
String msg) |
IgniteClientDisconnectedException(IgniteFuture<?> reconnectFut,
String msg,
@Nullable Throwable cause) |
| Modifier and Type | Method and Description |
|---|---|
IgniteFuture<?> |
ClusterTopologyException.retryReadyFuture() |
| Modifier and Type | Method and Description |
|---|---|
void |
ClusterTopologyException.retryReadyFuture(IgniteFuture<?> readyFut) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
ComputeTaskFuture<R>
This class defines a handler for asynchronous task execution.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteFuture<?> |
ComputeTaskSession.mapFuture()
Gets future that will be completed when task "map" step has completed
(which means that
ComputeTask.map(List, Object) method has finished). |
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteFuture<T> |
IgniteFuture.chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteFuture<T> |
IgniteFuture.chainAsync(IgniteClosure<? super IgniteFuture<V>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<R> IgniteFuture<R> |
IgniteAsyncSupport.future()
Deprecated.
since 2.0. Please use new specialized async method
e.g.
IgniteFuture f = cache.getAsync();
instead of old-style async API:
IgniteCache asyncCache = cache.withAsync();
asyncCache.get(key);
IgniteFuture fut = asyncCache.future();
|
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteFuture<T> |
IgniteFuture.chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteFuture<T> |
IgniteFuture.chainAsync(IgniteClosure<? super IgniteFuture<V>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
void |
IgniteFuture.listen(IgniteInClosure<? super IgniteFuture<V>> lsnr)
Registers a callback to be invoked when the future completes.
|
void |
IgniteFuture.listenAsync(IgniteInClosure<? super IgniteFuture<V>> lsnr,
Executor exec)
Registers a callback to be invoked with the specified executor when the future completes.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
SchedulerFuture<R>
Future for cron-based scheduled execution.
|
| Modifier and Type | Method and Description |
|---|---|
void |
IgniteSpiAdapter.onClientDisconnected(IgniteFuture<?> reconnectFut)
Client node disconnected callback.
|
void |
IgniteSpi.onClientDisconnected(IgniteFuture<?> reconnectFut)
Client node disconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteFuture<BitSet> |
TcpCommunicationSpi.checkConnection(List<ClusterNode> nodes) |
| Modifier and Type | Method and Description |
|---|---|
void |
TcpCommunicationSpi.onClientDisconnected(IgniteFuture<?> reconnectFut)
Client node disconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteFuture<?> |
DiscoverySpiListener.onDiscovery(DiscoveryNotification notification)
Notification for grid node discovery events.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteFuture<Void> |
Transaction.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteFuture<Void> |
Transaction.rollbackAsync()
Asynchronously rolls back this transaction.
|
Follow @ApacheIgnite
Ignite Database and Caching Platform : ver. 2.16.0 Release Date : December 15 2023