Hazelcast集群服务(1)——Hazelcast介绍

Hazelcast是什么

    “分布式”、“集群服务”、“网格式内存数据”、“分布式缓存“、“弹性可伸缩服务”——这些牛逼闪闪的名词拿到哪都是ITer装逼的不二之选。在Javaer的世界，有这样一个开源项目，只须要引入一个jar包、只需简单的配置和编码便可实现以上高端技能，他就是 Hazelcast。

    Hazelcast 是由Hazelcast公司（没错，这公司也叫Hazelcast！）开发和维护的开源产品，能够为基于jvm环境运行的各类应用提供分布式集群和分布式缓存服务。Hazelcast能够嵌入到任何使用Java、C++、.NET开发的产品中（C++、.NET只提供客户端接入）。Hazelcast目前已经更新到3.X版本，Java中绝大部分数据结构都被其觉得分布式的方式实现。好比Javaer熟悉的Map接口，当经过Hazelcast建立一个Map实例后，在节点A调用 Map::put("A","A_DATA") 方法添加数据，节点B使用 Map::get("A") 能够获到值为"A_DATA" 的数据。Hazelcast 提供了 Map、Queue、MultiMap、Set、List、Semaphore、Atomic 等接口的分布式实现；提供了基于Topic 实现的消息队列或订阅\发布模式；提供了分布式id生成器（IdGenerator）；提供了分布式事件驱动（Distributed Events）；提供了分布式计算（Distributed Computing）；提供了分布式查询（Distributed Query）。总的来讲在独立jvm常用数据结果或模型 Hazelcast 都提供了分布式集群的实现。

    Hazelcast 有开源版本和商用版本。开源版本遵循 Apache License 2.0 开源协议无偿使用。商用版本须要获取特定的License，二者之间最大的区别在于：商用版本提供了数据高密度存储。咱们都知道jvm有本身特定的GC机制，不管数据是在堆仍是栈中，只要发现无效引用的数据块，就有可能被回收。而Hazelcast的分布式数据都存放在jvm的内存中，频繁的读写数据会致使大量的GC开销。使用商业版的Hazelcast会拥有高密度存储的特性，大大下降Jvm的内存开销，从而下降GC开销。

    不少开源产品都使用Hazelcast 来组建微服务集群，例如我们的Vert.x，首选使用Hazelcast来组建分布式服务。有兴趣能够看个人这篇分享——http://my.oschina.net/chkui/blog/678347 ，文中说明了Vert.x如何使用Hazelcast组建集群。

    附：

• Hazelcast源码：https://github.com/hazelcast/hazelcast
• 关于Hazelcast的问题能够到https://github.com/hazelcast/hazelcast/issues或http://stackoverflow.com。

Hazelcast的特性

自治集群（无中心化）

    Hazelcast 没有任何中心节点（文中的节点能够理解为运行在任意服务器的独立jvm，下同），或者说Hazelcast 不须要特别指定一个中心节点。在运行的过程当中，它本身选定集群中的某个节点做为中心点来管理全部的节点。

数据按应用分布式存储

    Hazelcast 的数据是分布式存储的。他会将数据尽可能存储在须要使用该项数据的节点上，以实现数据去中心化的目的。在传统的数据存储模型中（MySql、MongDB、Redis 等等）数据都是独立于应用单独存放，当须要提高数据库的性能时，须要不断加固单个数据库应用的性能。即便是如今大量的数据库支持集群模式或读写分离，可是基本思路都是某几个库支持写入数据，其余的库不断的拷贝更新数据副本。这样作的坏处一是会产生大量脏读的问题，二是消耗大量的资源来传递数据——从数据源频繁读写数据会耗费额外资源，当数据量增加或建立的主从服务愈来愈多时，这个消耗呈指数级增加。

    使用 Hazelcast 能够有效的解决数据中心化问题。他将数据分散的存储在每一个节点中，节点越多越分散。每一个节点都有各自的应用服务，而Hazelcast集群会根据每一个应用的数据使用状况分散存储这些数据，在应用过程当中数据会尽可能“靠近”应用存放。这些在集群中的数据共享整个集群的存储空间和计算资源。

抗单点故障

    集群中的节点是无中心化的，每一个节点都有可能随时退出或随时进入。所以，在集群中存储的数据都会有一个备份（能够配置备份的个数，也能够关闭数据备份）。这样的方式有点相似于 hadoop，某项数据存放在一个节点时，在其余节点一定有至少一个备份存在。当某个节点退出时，节点上存放的数据会由备份数据替代，而集群会从新建立新的备份数据。

简易性

    全部的 Hazelcast 功能只需引用一个jar包，除此以外，他不依赖任何第三方包。所以能够很是便捷高效的将其嵌入到各类应用服务器中，而没必要担忧带来额外的问题（jar包冲突、类型冲突等等）。他仅仅提供一系列分布式功能，而不须要绑定任何框架来使用，所以适用于任何场景。

    除了以上特性，Hazelcast 还支持服务器/客户端模型，支持脚本管理、可以和 Docker 快速整合等等。

简单使用例子

    前面说了那么多概念，必需要来一点干货了。下面是一个使用 Hazelcast 的极简例子。文中的全部代码都在github上：https://github.com/chkui/hazelcast-demo。

    首先引入Hazelcast的jar包。

    Maven（pom.xml）：

<dependency>
    <groupId>com.hazelcast</groupId>
    <artifactId>hazelcast</artifactId>
    <version>${hazelcast.vertsion}</version>
</dependency>

    Gradle（build.gradle）：

compile com.hazelcast:hazelcast:${hazelcast.vertsion}

    先创一个建 Hazelcast 节点：

//org.palm.hazelcast.getstart.HazelcastGetStartServerMaster 
public class HazelcastGetStartServerMaster {
    public static void main(String[] args) {
        // 建立一个 hazelcastInstance实例
        HazelcastInstance instance = Hazelcast.newHazelcastInstance();
        // 建立集群Map
        Map<Integer, String> clusterMap = instance.getMap("MyMap");
        clusterMap.put(1, "Hello hazelcast map!");

        // 建立集群Queue
        Queue<String> clusterQueue = instance.getQueue("MyQueue");
        clusterQueue.offer("Hello hazelcast!");
        clusterQueue.offer("Hello hazelcast queue!");
    }
}

    上面的代码使用 Hazelcast 实例建立了一个节点。而后经过这个实例建立了一个分布式的Map和分布式的Queue，并向这些数据结构中添加了数据。运行这个main方法，会在console看到如下内容：

Members [1] {
    Member [192.168.1.103]:5701 this
}

     随后再建立另一个节点：

// org.palm.hazelcast.getstart.HazelcastGetStartServerSlave
public class HazelcastGetStartServerSlave {
    public static void main(String[] args) {
        //建立一个 hazelcastInstance实例
        HazelcastInstance instance = Hazelcast.newHazelcastInstance();
        Map<Integer, String> clusterMap = instance.getMap("MyMap");
        Queue<String> clusterQueue = instance.getQueue("MyQueue");
        
        System.out.println("Map Value:" + clusterMap.get(1));
        System.out.println("Queue Size :" + clusterQueue.size());
        System.out.println("Queue Value 1:" + clusterQueue.poll());
        System.out.println("Queue Value 2:" + clusterQueue.poll());
        System.out.println("Queue Size :" + clusterQueue.size());
    }
}

    该节点的做用是从Map、Queue中读取数据并输出。运行会看到如下输出

Members [2] {
    Member [192.168.1.103]:5701
    Member [192.168.1.103]:5702 this
}

八月 06, 2016 11:33:29 下午 com.hazelcast.core.LifecycleService
信息: [192.168.1.103]:5702 [dev] [3.6.2] Address[192.168.1.103]:5702 is STARTED
Map Value:Hello hazelcast map!
Queue Size :2
Queue Value 1:Hello hazelcast!
Queue Value 2:Hello hazelcast queue!
Queue Size :0

    至此，2个节点的集群建立完毕。第一个节点向map实例添加了{key:1,value:"Hello hazelcast map!"}，向queue实例添加[“Hello hazelcast!”,“Hello hazelcast queue!”]，第二个节点读取并打印这些数据。

    除了直接使用Hazelcast服务来组建集群，Hazelcast还提供了区别于服务端的客户端应用包。客户端与服务端最大的不一样是：他不会存储数据也不能修改集群中的数据。目前客户端有C++、.Net、Java多种版本。

    使用客户端首先要引入客户端jar包。

    Maven（pom.xml）：

<dependency>
    <groupId>com.hazelcast</groupId>
    <artifactId>hazelcast-client</artifactId>
    <version>${hazelcast.version}</version>
</dependency>

    Gradle（build.gradle）：

compile com.hazelcast:hazelcast-client:${hazelcast.vertsion}

    建立一个client节点。

public class HazelcastGetStartClient {
    public static void main(String[] args) {
        ClientConfig clientConfig = new ClientConfig();
        HazelcastInstance instance = HazelcastClient.newHazelcastClient(clientConfig);
        Map<Integer, String> clusterMap = instance.getMap("MyMap");
        Queue<String> clusterQueue = instance.getQueue("MyQueue");
        
        System.out.println("Map Value:" + clusterMap.get(1));
        System.out.println("Queue Size :" + clusterQueue.size());
        System.out.println("Queue Value 1:" + clusterQueue.poll());
        System.out.println("Queue Value 2:" + clusterQueue.poll());
        System.out.println("Queue Size :" + clusterQueue.size());
    }
}

    而后先启动 HazelcastGetStartServerMaster::main，再启动 HazelcastGetStartClient::main。能够看到客户端输出：

Members [1] {
    Member [192.168.197.54]:5701
}

八月 08, 2016 10:54:22 上午 com.hazelcast.core.LifecycleService
信息: HazelcastClient[hz.client_0_dev][3.6.2] is CLIENT_CONNECTED
Map Value:Hello hazelcast map!
Queue Size :2
Queue Value 1:Hello hazelcast!
Queue Value 2:Hello hazelcast queue!
Queue Size :0

    至此，客户端功能也建立完毕 。能够看到客户端的console输出内容比服务端少了不少，这是由于客户端没必要承载服务端的数据处理功能，也没必要维护各类节点信息。

例子运行解析

    下面咱们根据console的输出来看看 Hazelcast 启动时到底干了什么事。（下面的输出因环境或IDE不一样，可能会有差别）

class: com.hazelcast.config.XmlConfigLocator
info: Loading 'hazelcast-default.xml' from classpath. 

    这里输出的内容表示Hazelcast启动时加载的配置文件。若是用户没有提供有效的配置文件，Hazelcast会使用默认配置文件。后续的文章会详细说明 Hazelcast 的配置。

class: com.hazelcast.instance.DefaultAddressPicker
info: Prefer IPv4 stack is true.
class: com.hazelcast.instance.DefaultAddressPicker
info: Picked Address[192.168.197.54]:5701, using socket ServerSocket[addr=/0:0:0:0:0:0:0:0,localport=5701], bind any local is true

    这一段输出说明了当前 Hazelcast 的网络环境。首先是检测IPv4可用且检查到当前的IPv4地址是192.168.197.54。而后使用IPv6启用socket。在某些没法使用IPv6的环境上，须要强制指定使用IPv4，增长jvm启动参数：-Djava.net.preferIPv4Stack=true 便可。

class: com.hazelcast.system
info: Hazelcast 3.6.2 (20160405 - 0f88699) starting at Address[192.168.197.54]:5701
class: com.hazelcast.system
info: [192.168.197.54]:5701 [dev] [3.6.2] Copyright (c) 2008-2016, Hazelcast, Inc. All Rights Reserved.

     这一段输出说明了当前实例的初始化端口号是5701。Hazelcast 默认使用5701端口。若是发现该端口被占用，会+1查看5702是否可用，若是仍是不能用会继续向后探查直到5800。Hazelcast 默认使用5700到5800的端口，若是都没法使用会抛出启动异常。

class: com.hazelcast.system
info: [192.168.197.54]:5701 [dev] [3.6.2] Configured Hazelcast Serialization version : 1
class: com.hazelcast.spi.OperationService
info: [192.168.197.54]:5701 [dev] [3.6.2] Backpressure is disabled
class: com.hazelcast.spi.impl.operationexecutor.classic.ClassicOperationExecutor
info: [192.168.197.54]:5701 [dev] [3.6.2] Starting with 2 generic operation threads and 4 partition operation threads.

     这一段说明了数据的序列化方式和启用的线程。Hazelcast 在节点间传递数据有2种序列化方式，在后续的文章中会详细介绍。Hazelcast 会控制多个线程执行不一样的工做，有负责维持节点链接的、有负责数据分区管理的。

class: com.hazelcast.instance.Node
info: [192.168.197.54]:5701 [dev] [3.6.2] Creating MulticastJoiner
class: com.hazelcast.core.LifecycleService
info: [192.168.197.54]:5701 [dev] [3.6.2] Address[192.168.197.54]:5701 is STARTING
class: com.hazelcast.nio.tcp.nonblocking.NonBlockingIOThreadingModel
info: [192.168.197.54]:5701 [dev] [3.6.2] TcpIpConnectionManager configured with Non Blocking IO-threading model: 3 input threads and 3 output threads
class: com.hazelcast.cluster.impl.MulticastJoiner
info: [192.168.197.54]:5701 [dev] [3.6.2] 

     上面这一段输出中，Creating MulticastJoiner表示使用组播协议来组建集群。还建立了6个用于维护非拥塞信息输出\输出。

Members [1] {
    Member [192.168.197.54]:5701
    Member [192.168.197.54]:5702 this
}

class: com.hazelcast.core.LifecycleService
info: [192.168.197.54]:5701 [dev] [3.6.2] Address[192.168.197.54]:5701 is STARTED
class: com.hazelcast.partition.InternalPartitionService
info: [192.168.197.54]:5701 [dev] [3.6.2] Initializing cluster partition table arrangement...

    Members[2]表示当前集群只有2个节点。2个节点都在ip为192.168.197.54的这台设备上，2个节点分别占据了5701端口和5702端口。端口后面的this说明这是当前节点，而未标记this的是其余接入集群的节点。最后InternalPartitionService输出的信息表示集群初始化了“数据分片”，后面会介绍“数据分片”的概念和原理。

    上面就是Hazelcast在默认状况下执行的启动过程，能够看出在初始化的过程当中咱们能够有针对性的修改一些Hazelcast的行为：

1. 使用默认配置文档 hazelcast-default.xml 来启动集群。所以咱们能够自定义这个配置文件来影响Hazelcast 的行为。
2. 启用IPv4或IPv6来创建集群，所以能够知道Hazelcast集群的通讯是基于TCP、UDP，须要打开socket支持集群交互。所以咱们能够指定使用的通信方案。
3. Hazelcast会启动多个线程来执行不一样的工做，有些负责维护数据、有些负责集群通讯、有些负责一些基础操做。所以咱们能够配置和管理这些线程。
4. Hazelcast默认使用MulitCast（组播协议）来组建集群，所以在局域网环境他能够无需配置本身完成集群组建。所以咱们能够指定使用TCP/IP或其余通信协议。
5. Hazelcast会本身探寻可使用的端口，默认状况下会使用5700到5800间没有被占用的端口。所以咱们能够配置这些端口如何使用。
6. Hazelcast初始化一个名为“数据分片”的方案来管理和存储数据。所以咱们能够调整和控制这些数据分片。

    以上全部红色字体的部分均可以经过配置文件来影响。在后续的文章中会详细介绍相关的 配置说明（待续）。

-----------------------------------亮瞎人的分割线-----------------------------------

    若是对Hazelcast的基本原理没什么兴趣，就不用向下看“运行结构“和“数据分片原理”了，直接去下一篇了解如何使用Hazelcast吧。

Hazelcast运行结构

    Hazelcast的官网上列举了2种运行模式，一种是p2p（点对点）模式、一种是在点对点模式上扩展的C/S模式。下图是p2p模式的拓补结构。

    在p2p模式中，全部的节点（Node）都是集群中的服务节点，提供相同的功能和计算能力。每一个节点都分担集群的整体性能，每增长一个节点均可以线性增长集群能力。

    在p2p服务集群的基础上，咱们能够增长许多客户端接入到集群中，这样就造成了集群的C/S模式，提供服务集群视做S端，接入的客户端视做C端。这些客户端不会分担集群的性能，可是会使用集群的各类资源。下图的结构就是客户端接入集群的状况。

    能够为客户端提供特别的缓存功能，告知集群让那些它常常要使用的数存放在“离它最近”的节点。

Hazelcast分片概念与原理

   Hazelcast经过分片来存储和管理全部进入集群的数据，采用分片的方案目标是保证数据能够快速被读写、经过冗余保证数据不会因节点退出而丢失、节点可线性扩展存储能力。下面将从理论上说明Hazelcast是如何进行分片管理的。

分片

    Hazelcast的每一个数据分片（shards）被称为一个分区（Partitions）。分区是一些内存段，根据系统内存容量的不一样，每一个这样的内存段都包含了几百到几千项数据条目，默认状况下，Hazelcast会把数据划分为271个分区，而且每一个分区都有一个备份副本。当启动一个集群成员时，这271个分区将会一块儿被启动。

    下图展现了集群只有一个节点时的分区状况。

                            

    从一个节点的分区状况能够看出，当只启动一个节点时，全部的271个分区都存放在一个节点中。而后咱们启动第二个节点。会出现下面这样的分区方式。

                            

    二个节点的图中，用黑色文字标记的表示主分区，用蓝色文字标记的表示复制分区（备份分区）。第一个成员有135个主分区（黑色部分），全部的这些分区都会在第二个成员中有一个副本（蓝色部分），一样的，第一个成员也会有第二个成员的数据副本。

    当增长更多的成员时，Hazelcast会将主数据和备份数据一个接一个的迁移到新成员上，最终达成成员之间数据均衡且相互备份。当Hazelcast发生扩展的时候，只有最小数量的分区被移动。下图呈现了4个成员节点的分区分布状况。

                           

    上面的几个图说明了的Hazelcast是如何执行分区的。一般状况下，分区的分布状况是无序的，他们会随机分布在集群中的各个节点中。最重要的是，Hazelcast会平均分配成员以前的分区，并均匀在的成员之间建立备份。

    在Hazelcast 3.6版本中，新增了一种集群成员：“精简成员”（lite members），他的特色是不拥有任何分区。“精简成员”的目标是用于“高密度运算”任务（computationally-heavy task executions。估计是指CPU密集型运算）或者注册监听（listener） 。虽然“精简成员”没有本身的分区，可是他们一样能够访问集群中其余成员的分区。

    总的来讲，当集群中的节点发送变更时（进入或退出），都会致使分区在节点中移动并再平衡，以确保数据均匀存储。但如果“精简节点”的进入或退出，并不会出现从新划分分区状况，由于精简节点并不会保存任何分区。

数据分区管理

    建立了分区之后，Hazelcast会将全部的数据存放到每一个分区中。它经过哈希运算将数据分布到每一个分区中。获取存储数据Key值（例如map）或value值（例如topic、list），而后进行如下处理：

1. 将设定的key或value转换成byte[]；
2. 对转换后的byte[]进行哈希计算；
3. 将哈希计算的结果和分区的数量（271）进行模运算（同余运算、mod运算、%运算）。

    由于byte[]是和271进行同模运算，所以计算结果必定会在0~270之间，根据这个值能够指定到用于存放数据的分区。

分区表

    当建立分区之后，集群中的全部成员必须知道每一个分区被存储到了什么节点。所以集群还须要维护一个分区表来追踪这些信息。

    当启动第一个节点时，一个分区表将随之建立。表中包含分区的ID和标记了他所属的集群节点。分区表的目标就是让集群中全部节点（包括“精简节点”）都能获取到数据存储信息，确保每一个节点都知道数据在哪。集群中最老的节点（一般状况下是第一个启动的成员）按期发送分区表给全部的节点。以这种方式，当分区的全部权发生变更时，集群中的全部节点都会被通知到。分区的全部权发生变更有不少种状况，好比，新加入一个节点、或节点离开集群等。若是集群中最先启动的节点被关闭，那么随后启动的节点将会继承发送分区表的任务，继续将分区表发送给全部成员。

原文地址：https://my.oschina.net/chkui/blog/729698