标签: hazelcast-imap

我的基于Hazelcast的程序可以在两种模式下工作:提交者和工作者.

提交者通过某些键将一些POJO放入分布式地图,例如: hazelcastInstance.getMap(MAP_NAME).put(key, value);

Worker有一个无限循环(Thread.sleep(1000L);内部为超时),它必须处理map中的实体.现在我只是在这个循环中打印地图大小.

现在这是问题所在.我开始工作的应用程序 然后我同时启动四个提交者(每个提交者都添加一个条目并终止它的工作).但是在完成所有提交者应用程序之后,工作者应用程序打印出任意大小:有时它会检测到只添加了一个条目,有时是两个,有时是三个(实际上它从未见过所有四个条目).

这个简单的流程有什么问题？我在Hazelcast文档中读到put()方法是同步的,因此它保证在它返回后,将条目放入分布式映射并进行复制.但在我的实验中似乎并非如此.

UPD(代码)

发布者:

public void submit(String key) {
    Object mySerializableObject = ...
    IMap<String, Object> map = hazelcastInstance.getMap(MAP_NAME);
    map.putIfAbsent(key, mySerializableObject, TASK_TTL_IN_HOURS, TimeUnit.HOURS);
}

工人:

public void process() {
    while (true) {
        IMap<String, Object> map = hazelcastInstance.getMap(MAP_NAME);
        System.out.println(map.size());

        // Optional<Map.Entry<String, Object>> objectToProcess = getObjectToProcess();
        // objectToProcess.ifPresent(objectToProcess-> processObject(id, objectToProcess));
        try {
            Thread.sleep(PAUSE);
        } catch (InterruptedException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }
}

我注释掉了"处理"部分本身,因为现在我只是试图获得地图的一致状态.上面的代码每次打印不同的结果,例如:"4,3,1,1,1,1,1 ......"(因此它甚至可以看到4个提交的任务片刻,但随后它们......消失) .

UPD(日志)

工人:

...
tasksMap.size() = …

什么是在段中定义的<hz:map>标签中创建的标签之间的区别applicationContext是<hz:config>什么？

它们有什么关系？

我知道<hz:map>in applicationContext会导致创建一个IMap类型的bean,当没有<hz:map>那个时它就不会.

但是,当定义了bean并且随后<hz:map>在hazelcast配置下具有相同名称时,以下配置会执行什么操作？

<hz:map id="loggedInUserMap" name="loggedInUserMap" instance-ref="ipds" scope="singleton" />
<hz:hazelcast id="ipds">

        <hz:config>

            <hz:instance-name>${hz.instance.name}</hz:instance-name>
            <hz:group name="${hz.group.name}" password="${hz.group.password}"/>

            <hz:map name="loggedInUserMap" backup-count="1" eviction-policy="NONE" in-memory-format="BINARY">
                <hz:near-cache time-to-live-seconds="0" max-idle-seconds="60"
                               eviction-policy="LRU" max-size="5000"  invalidate-on-change="true"/>
            </hz:map>

        </hz:config>

    </hz:hazelcast>

我有一个性能用例，通过该用例，我需要确定花费300毫秒以上的某些process()调用EntryProcessor。我尝试使用SlowOperationDetector以下配置。

    <!-- SlowOperation Detector Configuration -->
    <property name="hazelcast.slow.operation.detector.enabled">true</property>
    <property name="hazelcast.slow.operation.detector.stacktrace.logging.enabled">true</property>
    <property name="hazelcast.slow.operation.detector.log.purge.interval.seconds">60000</property>
    <property name="hazelcast.slow.operation.detector.log.retention.seconds">60000</property>
    <property name="hazelcast.slow.operation.detector.threshold.millis">300</property>

我给出了一个示例测试代码，该代码在内部睡眠1秒钟process()。

public static void main(String args[])
{
    Config cfg = null;
    try {
        cfg = new FileSystemXmlConfig("C:\\workarea\\hazelcast\\hazelcast-perf.xml");
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance(cfg);
    IMap<String, Employee> employeesMap = hazelcastInstance.getMap("anyMap");
    employeesMap.put("100", new Employee(100));
    SlowEntryProcessor slowEntryProcessor = new SlowEntryProcessor();
    employeesMap.executeOnKey("100", slowEntryProcessor);

}

static public class SlowEntryProcessor implements EntryProcessor<String, Employee> …

我知道<min-eviction-check-millis>在hazelcast配置中定义了在检查此映射的分区是否可逐出之前应该通过的最短时间(以毫秒为单位).因此,在每个配置的间隔期间,将根据配置的驱逐策略在地图中执行驱逐.我有以下与此领域相关的问题.

Q1.驱逐操作是否在操作线程上运行？

Q2.驱逐操作会锁定它正在处理的整个分区吗？

Q3.如果我要遵循100毫秒的默认值(我相信这是一个非常小的值),我是否需要预期会有任何性能损失.

Q4.在以下情景中,驱逐行动的频率如何？

<map name="employees">
    <in-memory-format>BINARY</in-memory-format>
    <backup-count>1</backup-count>
    <max-idle-seconds>1800</max-idle-seconds>
    <eviction-policy>NONE</eviction-policy>
    <time-to-live-seconds>0</time-to-live-seconds>
    <min-eviction-check-millis>1000</min-eviction-check-millis>
    <max-size>0</max-size>
    <eviction-percentage>0</eviction-percentage>
    <merge-policy>com.hazelcast.map.merge.PutIfAbsentMapMergePolicy</merge-policy>

</map>

请注意,虽然没有配置驱逐策略和百分比,但最大空闲时间设置为1800秒.

上述问题的答案将帮助我在大规模部署中对这些配置所使用的值做出明智的决定.

现在我们正在使用默认选项 .getMap() 创建地图。我们不使用 getConfig().addMapConfig 选项，因为我们想避免检查地图是否为空等，以避免每次需要访问地图时调用此代码（由接口 getMap() 抽象的客户端代码）。

现在的问题是，如果我们想销毁某些地图，我们希望遍历所有地图名称并仅销毁符合特定条件的地图。由于我们没有添加到 MapConfig，我们无法使用 getConfig().getMapConfigs().keyset() 来获取地图名称。

现在我们正在尝试使用 .getDistributedObjects() 进行迭代。唯一担心的是分布式对象作为一个整体加载在内存中（我希望不是..），或者只是加载到 DistributedObject 引用中的 ID 和名称（如代理）。我无法从代码中看出。这样做是个好主意还是有更好的方法来获取地图对象引用。请帮忙

我们配置<time-to-live-seconds>为1200(20分钟)但缓存在缓存创建时间一分钟后自动逐出.

有人可以告诉如何在指定的时间段内使缓存生效吗？

有没有办法在hazelcast DB中为每条记录设置TTL？最好是在Map或Ringbuffer中.

我们正在评估 Hazelcast 的一个用例，但我对 Hazelcast 中的复制有疑问。

http://docs.hazelcast.org/docs/latest-development/manual/html/Distributed_Data_Structures/Map/Backing_Up_Maps.html中提到“备份操作是同步的，因此当map.put(key, value)返回时，保证映射条目被复制到另一个成员”。

但在另一个页面http://docs.hazelcast.org/docs/latest-development/manual/html/Consistency_and_Replication_Model.html中，提到“有两种类型的备份复制可用：同步和异步。不管它们的名字暗示什么，这两种类型仍然是惰性（异步）复制模型的实现”。

这两种说法看起来都有点矛盾。有人可以解释一下吗？

Hazelcast 中的复制真的是同步的吗？我需要同时更新所有者节点和备份节点中的值。

我们正在尝试在我们的应用程序中使用Hazelcast作为分布式缓存.这是我们的配置:

<hazelcast xsi:schemaLocation="http://www.hazelcast.com/schema/config hazelcast-config-3.7.xsd" xmlns="http://www.hazelcast.com/schema/config"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <group>
      <name>sample_dev</name>
      <password>dev@123</password>
   </group>
   <management-center enabled="false">http://localhost:8080/mancenter</management-center>
   <properties>
      <property name="hazelcast.logging.type">slf4j</property>
      <property name="hazelcast.socket.bind.any">false</property>
   </properties>
   <serialization>
      <serializers>
         <global-serializer override-java-serialization="true">com.prasanth.common.KryoSerializer</global-serializer>
      </serializers>
   </serialization>
   <network>
      <join>
         <multicast enabled="false"/>
         <tcp-ip enabled="true">
            <member-list>
               <member>127.0.0.1:5701</member>
            </member-list>
         </tcp-ip>
      </join>
      <interfaces enabled="false">
         <interface>192.168.3.*</interface>
      </interfaces>
   </network>
   <map name="com.prasanth.cache.CachedAsset">
      <in-memory-format>BINARY</in-memory-format>
      <backup-count>1</backup-count>
      <async-backup-count>1</async-backup-count>
      <time-to-live-seconds>86400</time-to-live-seconds>
      <max-idle-seconds>1200</max-idle-seconds>
      <eviction-policy>LRU</eviction-policy>
      <max-size policy="PER_NODE">4500</max-size>
      <merge-policy>com.hazelcast.map.merge.LatestUpdateMapMergePolicy</merge-policy>
      <!--<read-backup-data>true</read-backup-data>-->
      <near-cache>
         <in-memory-format>OBJECT</in-memory-format>
         <cache-local-entries>true</cache-local-entries>
         <time-to-live-seconds>86400</time-to-live-seconds>
         <max-idle-seconds>1200</max-idle-seconds>
         <invalidate-on-change>true</invalidate-on-change>
      </near-cache>
   </map>
</hazelcast>

从文档中,我可以看到,每次调用Hazelcast时,都会涉及反序列化.因此,为了优化调用,我们使用Kryo作为默认序列化器并实现了近缓存.我们必须将每个大小为500KB的对象放入地图中,并且我们可以在内存中有大约400-500个这样的活动对象.我们经常在应用程序中使用缓存.

之前我们使用EhCache和JGroups配置缓存实现.操作速度非常快.但是当我们尝试使用Hazelcast时,我发现操作时间有很大差异.我可以说,Hazelcast不仅仅是一个缓存实现.但只是想知道为什么与EhCache(使用jgroups)相比,操作变得非常慢.我们的配置是否有问题？请指教!

另请注意,我正在单节点机器上测试它.

我正在使用“ hazelcast.operation.call.timeout.millis = 100”配置来使hazelcast操作超时。

但是，在启动hazelcast时，由于此配置，某些地图大小操作正在超时。我只想在地图加载后使基本上是地图获取操作的操作超时。有什么方法可以为这些map.get（）操作添加自定义操作超时？

还有其他方法可以做到这一点吗？

com.hazelcast.core.OperationTimeoutException: HDMapSizeOperation got rejected before execution due to not starting within the operation-call-timeout of: 100ms. Current time: 2017-05-15 11:41:47.503. Start time: 2017-05-15 11:41:44.189. Total elapsed time: 3314 ms. Invocation{op=com.hazelcast.map.impl.operation.HDMapSizeOperation{serviceName='hz:impl:mapService', identityHash=1941379381, partitionId=0, replicaIndex=0, callId=-24461, invocationTime=1494828707296 (2017-05-15 11:41:47.296), waitTimeout=-1, callTimeout=100, name=blockMap}, tryCount=250, tryPauseMillis=500, invokeCount=11, callTimeoutMillis=100, firstInvocationTimeMs=1494828704189, firstInvocationTime='2017-05-15 11:41:44.189', lastHeartbeatMillis=0, lastHeartbeatTime='1970-01-01 05:30:00.000', target=[192.168.2.204]:5701, pendingResponse={VOID}, backupsAcksExpected=0, backupsAcksReceived=0, connection=null}
at com.hazelcast.spi.impl.operationservice.impl.InvocationFuture.newOperationTimeoutException(InvocationFuture.java:151)
at com.hazelcast.spi.impl.operationservice.impl.InvocationFuture.resolve(InvocationFuture.java:99)
at com.hazelcast.spi.impl.operationservice.impl.InvocationFuture.resolveAndThrowIfException(InvocationFuture.java:75)
at com.hazelcast.spi.impl.AbstractInvocationFuture.get(AbstractInvocationFuture.java:155)
at com.hazelcast.spi.impl.operationservice.impl.InvokeOnPartitions.retryFailedPartitions(InvokeOnPartitions.java:143)
at com.hazelcast.spi.impl.operationservice.impl.InvokeOnPartitions.invoke(InvokeOnPartitions.java:73)
at com.hazelcast.spi.impl.operationservice.impl.OperationServiceImpl.invokeOnAllPartitions(OperationServiceImpl.java:371)
at com.hazelcast.map.impl.proxy.MapProxySupport.size(MapProxySupport.java:628)
at com.hazelcast.map.impl.proxy.MapProxyImpl.size(MapProxyImpl.java:102) …