This is a continuation of a series explaining how to use Hazelcast. If one has not read the other six posts, please go to the Table Of Contents and read the other posts.
A Different Breed of Map
Hazelcast’s MultiMap breaks the normal mold of using java.util.Collection interfaces that have been used in former posts. In fact, the concept of a MultiMap breaks the idea of a map altogether in my opinion. While normal maps associate one key to one value, MultiMaps can map multiple values to the same key. That is a really important concept, multiple values to the same key. Values can be stored in two different collections, set or list. These collections act like the collections of java.util.Collections library.
Is it Safe?
MultiMaps have a method to their madness. In a normal map, multiple values per key can be stored but it has to be done manually. That means getting a collection out of storage, doing any changes and then putting the collection back into storage. This can be problematic for thread safety because the prior steps need to be done atomically or there is the possibility of stale or inconsistent data being read by other threads. MultiMaps help with this problem by offering the following services:
- One can add a value via a single put operation.
- One can lock an entry by the key. This is key (pun intended) because this means the developer does not have to keep track of a separate lock per entry.
Example
This example is a little different because I used Maven’s failsafe plugin as the main engine when running the examples. Yes, I wrote two examples because I wanted to show two different ways of using a MultiMap. One way is every thread getting their own playground, being assigned an unique key, or being assigned a shared playground or all of the threads sharing the same key. This also is an example of how Hazelcast’s IdGenerator can be used as a method of creating thread safety in an application.
Pom File
Remember, this example code takes advantage of Apache’s Failsafe Maven plugin. The failsafe plugin aids in automated integration tests by not killing the build at the first failure. It is a fork of the surefire plugin. I also have been experimenting with the reporting that is available with Maven. Type “mvn site” at the command line and it will generate a website.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0>
<groupId>com.darylmathison>
<artifactId>hazelcast-multimap-example>
<version>1.0-SNAPSHOT>
<description>Examples of using Hazelcast Multimap>
<developers>
<developer>
<name>Daryl Mathison>
<id>dmathison>
<roles>
<role>developer>
>
>
>
<scm>
<connection>scm:git:https://github.com/darylmathison/hazelcast-multimap-example.git>
<url>https://github.com/darylmathison/hazelcast-multimap-example>
>
<properties>
<maven.compiler.source>1.8>
<maven.compiler.target>1.8>
<project.build.sourceEncoding>UTF-8>
>
<dependencies>
<dependency>
<groupId>com.hazelcast>
<artifactId>hazelcast>
<version>3.4.2>
>
<dependency>
<groupId>junit>
<artifactId>junit>
<version>4.12>
<scope>test>
>
>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins>
<artifactId>maven-failsafe-plugin>
<version>2.18.1>
<executions>
<execution>
<goals>
<goal>integration-test>
<goal>verify>
>
>
>
>
>
>
<reporting>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins>
<artifactId>maven-project-info-reports-plugin>
<version>2.7>
<reportSets>
<reportSet>
<reports>
<report>dependencies>
<report>index>
<report>project-team>
<report>scm>
>
>
>
>
<plugin>
<groupId>org.apache.maven.plugins>
<artifactId>maven-javadoc-plugin>
<version>2.10.3>
<reportSets>
<reportSet>
<reports>
<report>javadoc>
<report>test-javadoc>
>
>
>
>
<plugin>
<groupId>org.apache.maven.plugins>
<artifactId>maven-surefire-report-plugin>
<version>2.18.1>
>
<plugin>
<groupId>org.apache.maven.plugins>
<artifactId>maven-jxr-plugin>
<version>2.5>
<configuration>
<linkJavadoc>true>
>
<reportSets>
<reportSet>
<reports>
<report>jxr>
<report>test-jxr>
>
>
>
>
>
>
>MultimapAccessThread
This is the base class for each of the access type threads.
package com.darylmathison.multimap;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.HazelcastInstanceAware;
import com.hazelcast.core.MultiMap;
import java.io.Serializable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Abstract class to access MultiMap.
*/
public abstract class MultiMapAccessThread implements Serializable, Runnable, HazelcastInstanceAware {
protected com.hazelcast.core.HazelcastInstance instance;
protected MultiMap<Long, Long> map;
protected String mapName;
protected Lock l = new ReentrantLock();
public void setHazelcastInstance(HazelcastInstance instance) {
l.lock();
try {
this.instance = instance;
if (mapName != null && !mapName.isEmpty()) {
map = instance.getMultiMap(mapName);
}
} finally {
l.unlock();
}
}
public String getMapName() {
return mapName;
}
public void setMapName(String mapName) {
l.lock();
try {
this.mapName = mapName;
} finally {
l.unlock();
}
}
}IdMultiMapAccessThread
package com.darylmathison.multimap;
/**
* This thread accesses only one "slot" in a multimap.
*/
public class IdMultiMapAccessThread extends MultiMapAccessThread {
private Long id;
@Override
public void run() {
l.lock();
boolean shouldRun = (map != null && id != null);
l.unlock();
if(shouldRun) {
for (long i = 0; i < 10; i++) {
map.put(id, i);
}
}
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}GroupMultiMapAccessThread
package com.darylmathison.multimap;
/**
* Thread designed to share the same "slot" on a MultiMap.
*/
public class GroupMultiMapAccessThread extends MultiMapAccessThread {
private static final long MAX = 10;
private Long groupId;
/**
* When an object implementing interface Runnable is used
* to create a thread, starting the thread causes the object's
* run method to be called in that separately executing
* thread.
** The general contract of the method run is that it may
* take any action whatsoever.
*
* @see Thread#run()
*/
@Override
public void run() {
l.lock();
boolean shouldRun = (groupId != null && map != null);
l.unlock();
if(shouldRun) {
map.lock(groupId);
try {
if (map.get(groupId).isEmpty()) {
System.out.println("adding to list");
for (long i = 0; i < MAX; i++) {
map.put(groupId, i);
}
} else {
System.out.println("nothing to add");
}
} finally {
map.unlock(groupId);
}
}
}
public void setGroupId(Long groupId) {
l.lock();
this.groupId = groupId;
l.unlock();
}
}HazelcastInstanceResource
This rule starts up and shuts down the Hazelcast instance needed for running the threads.
package com.darylmathison.multimap.test.rule;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IExecutorService;
import org.junit.rules.ExternalResource;
/**
* Created by Daryl on 4/27/2015.
*/
public class HazelcastInstanceResource extends ExternalResource {
public static final String SERVICE_NAME = "Charlotte";
HazelcastInstance instance;
IExecutorService service;
@Override
protected void before() throws Throwable {
super.before();
instance = Hazelcast.newHazelcastInstance();
service = instance.getExecutorService(SERVICE_NAME);
}
@Override
protected void after() {
super.after();
service.shutdown();
instance.shutdown();
}
public HazelcastInstance getInstance() {
return instance;
}
public IExecutorService getService() {
return service;
}
}IdMultiMapAccessIT
Here is an example of using the IdGenerator to create new “playgrounds” or keys for the threads to place data.
package com.darylmathison.multimap;
import com.darylmathison.multimap.test.rule.HazelcastInstanceResource;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IExecutorService;
import com.hazelcast.core.IdGenerator;
import org.junit.ClassRule;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
/**
* Integration test for IdMultiMapAccessThread
*/
public class IdMultiMapAccessThreadIT {
public static final String MAP_NAME = "idAccessMap";
public static final String GEN_NAME = "singleAccess";
public static final int NUM_THREADS = 10;
@ClassRule
public static HazelcastInstanceResource hazelcastInstanceResource = new HazelcastInstanceResource();
@Test
public void testIdThreads() {
List threads = generateThreads(hazelcastInstanceResource.getInstance());
List<Future<?>> futures = new ArrayList<>(NUM_THREADS);
IExecutorService spinner = hazelcastInstanceResource.getService();
for(IdMultiMapAccessThread thread: threads) {
futures.add(spinner.submit(thread));
}
for(Future<?> future: futures) {
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
private List generateThreads(HazelcastInstance instance) {
IdGenerator gen = instance.getIdGenerator(GEN_NAME);
List threads = new ArrayList<>(NUM_THREADS);
for(int i = 0; i < NUM_THREADS; i++) {
IdMultiMapAccessThread thread = new IdMultiMapAccessThread();
thread.setMapName(MAP_NAME);
thread.setId(gen.newId());
threads.add(thread);
}
return threads;
}
}GroupMultiMapAccessThreadIT
This is an example of using an IdGenerator to create a shared playground or slot.
package com.darylmathison.multimap;
import com.darylmathison.multimap.test.rule.HazelcastInstanceResource;
import com.hazelcast.core.IExecutorService;
import com.hazelcast.core.IdGenerator;
import org.junit.ClassRule;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
/**
* GroupMultiMapAccessThread Integration Test
*/
public class GroupMultiMapAccessThreadIT {
public static final int NUM_THREADS = 10;
public static final String GEN_NAME = "groupIdGenerator";
public static final String MAP_NAME = "groupMap";
@ClassRule
public static HazelcastInstanceResource hazelcastInstanceResource = new HazelcastInstanceResource();
@Test
public void testGroupMultiMapAccessThread() {
List threads = createThreads();
IExecutorService service = hazelcastInstanceResource.getService();
List<Future<?>> futures = new ArrayList<>(NUM_THREADS);
for(GroupMultiMapAccessThread thread: threads) {
futures.add(service.submit(thread));
}
for(Future<?> future: futures) {
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
private List createThreads() {
List ret = new ArrayList<>(NUM_THREADS);
IdGenerator gen = hazelcastInstanceResource.getInstance().getIdGenerator(GEN_NAME);
Long groupId = gen.newId();
for(int i = 0; i < NUM_THREADS; i++) {
GroupMultiMapAccessThread thread = new GroupMultiMapAccessThread();
thread.setMapName(MAP_NAME);
thread.setGroupId(groupId);
ret.add(thread);
}
return ret;
}
}Conclusion
In this post, Hazelcast’s MultiMap was profiled. It was shown that MultiMaps can store multiple values for a given key. It was also shown how a thread can share the data in a MultiMap or can store data for itself using the IdGenerator as a possible key generator. The code can be found in GitHub here.
References
| Reference: | Beginner’s Guide to Hazelcast Part 7 from our JCG partner Daryl Mathison at the Daryl Mathison’s Java Blog blog. |
