Hazelcast

Language: Java

Performance / In-Memory Data Grid

Hazelcast was developed to enable real-time, scalable, and fault-tolerant data processing across clusters. It supports in-memory computing, distributed caching, and event-driven architectures, making it ideal for microservices, high-throughput applications, and low-latency systems.

Hazelcast is a distributed in-memory data grid and caching platform for Java. It provides high-performance storage for key-value data, distributed maps, queues, topics, and support for distributed computing, clustering, and transactions.

Installation

maven:

<dependency>
  <groupId>com.hazelcast</groupId>
  <artifactId>hazelcast</artifactId>
  <version>5.3.2</version>
</dependency>

gradle: implementation 'com.hazelcast:hazelcast:5.3.2'

Usage

Hazelcast provides distributed collections such as maps, sets, queues, lists, and topics. It supports automatic clustering, distributed computation, transactions, and persistence to ensure data reliability. Developers can integrate Hazelcast as a cache, compute grid, or in-memory database.

Starting a Hazelcast instance and using a map

import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.map.IMap;

HazelcastInstance hz = Hazelcast.newHazelcastInstance();
IMap<Integer, String> map = hz.getMap("myMap");
map.put(1, "Hello Hazelcast");
System.out.println(map.get(1));
hz.shutdown();

Starts a Hazelcast node, creates a distributed map, stores and retrieves a value, and shuts down the instance.

Using distributed queue

import com.hazelcast.collection.IQueue;
IQueue<String> queue = hz.getQueue("myQueue");
queue.add("Task1");
System.out.println(queue.poll());

Demonstrates using a distributed queue for inter-node task processing.

Executing distributed computation

hz.getExecutorService("exec").submit(() -> System.out.println("Running task across cluster"));

Executes a task across cluster nodes using Hazelcast's distributed executor service.

Transactions

import com.hazelcast.transaction.TransactionContext;
TransactionContext context = hz.newTransactionContext();
context.beginTransaction();
try {
    IMap<Integer, String> mapTx = context.getMap("myMap");
    mapTx.put(2, "Transactional Value");
    context.commitTransaction();
} catch(Exception e) {
    context.rollbackTransaction();
}

Performs atomic operations on distributed data using transactions.

Event listeners

map.addEntryListener(entryEvent -> System.out.println("Entry updated: " + entryEvent), true);

Adds a listener to monitor map entry events across the cluster.

Error Handling

HazelcastInstanceNotActiveException: Occurs if instance is shut down or not active. Ensure the Hazelcast instance is running.

TransactionException: Thrown if transaction fails. Handle commit/rollback appropriately.

IllegalStateException: Occurs if configuration is invalid or cluster is unstable. Validate cluster setup and configuration.

Best Practices

Use appropriate collection types (map, queue, set) based on use case.

Enable backups for high availability and fault tolerance.

Use transactions for critical operations to ensure consistency.

Monitor cluster performance and adjust partitions and backups accordingly.

Leverage Hazelcast management center for monitoring and tuning cluster.

Official Docs Github