Java 如何在hazelcast 3.x中显示所有结构名称

我发现，但这是2年前的事了，对于以前的版本，它在Hz3.x中不起作用。所以，我的问题是如何在Hz3.x中实现这一点

---

像APP1 open lock 1、APP2 open lock 2一样，我如何知道已经使用的所有锁？

找到了一种方法，有很多技巧，适用于任何服务

首先运行svr，然后运行cli和测试

public class PlayHZ
{
    @Test
    public void test() throws ExecutionException, InterruptedException
    {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        IExecutorService executor = hz.getExecutorService("gather");
        Map<Member, Future<List<String>>> futures = executor.submitToAllMembers(new LockNameGather());
        Thread.sleep(1000);
        System.out.println("Found in member");
        for (Map.Entry<Member, Future<List<String>>> entry : futures.entrySet())
        {
            System.out.printf("%s -> %s\n", entry.getKey(), entry.getValue().get());
        }
    }

    @Test
    public void svr() throws InterruptedException
    {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        Thread.sleep(Integer.MAX_VALUE);
    }

    @Test
    public void cli() throws InterruptedException
    {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        for (int i = 0; i < 100; i++)
        {
            ILock lock = hz.getLock("LOCK" + i);
            lock.lock();
        }
        Thread.sleep(Integer.MAX_VALUE);
    }

    private static class LockNameGather implements Callable<List<String>>, HazelcastInstanceAware, Serializable
    {
        transient HazelcastInstance hz;
        transient NodeEngineImpl node;

        @Override
        public List<String> call() throws Exception
        {
            node = ((HazelcastInstanceImpl) hz).node.getNodeEngine();
            LockService svc = node.getService(LockService.SERVICE_NAME);

            return svc.getAllLocks()
                      .stream()
                      .map(LockResource::getKey)
                      .map(d -> node.getSerializationService().createObjectDataInput(d))
                      .map((r) -> {
                          try
                          {
                              return r.readUTF();
                          } catch (IOException e)
                          {
                              throw new RuntimeException(e);
                          }
                      }).collect(Collectors.toList());
        }

        @Override
        public void setHazelcastInstance(HazelcastInstance hazelcastInstance)
        {
            hz = hazelcastInstance;
        }
    }
}

公共类PlayHZ
{
@试验
public void test（）引发ExecutionException、InterruptedException
{
HazelcastInstance hz=Hazelcast.newHazelcastInstance（）；
IExecutorService executor=hz.getExecutorService（“收集”）；
Map futures=executor.submitToAllMembers（新的LockNameGather（））；
睡眠（1000）；
System.out.println（“在成员中找到”）；
for（Map.Entry:futures.entrySet（））
{
System.out.printf（“%s->%s\n”，entry.getKey（），entry.getValue（）.get（））；
}
}
@试验
public void svr（）引发InterruptedException
{
HazelcastInstance hz=Hazelcast.newHazelcastInstance（）；
Thread.sleep（整数.MAX_值）；
}
@试验
public void cli（）引发InterruptedException
{
HazelcastInstance hz=Hazelcast.newHazelcastInstance（）；
对于（int i=0；i<100；i++）
{
ILock lock=hz.getLock（“lock”+i）；
lock.lock（）；
}
Thread.sleep（整数.MAX_值）；
}
私有静态类LockNameGather实现可调用、HazelCastInstanceWare、可序列化
{
瞬态HazelcastInstance hz；
瞬态节点工程节点；
@凌驾
公共列表调用（）引发异常
{
node=（（HazelcastInstanceImpl）hz）.node.getNodeEngine（）；
LockService svc=node.getService（LockService.SERVICE\u名称）；
返回svc.getAllLocks（）
.stream（）
.map（LockResource:：getKey）
.map（d->node.getSerializationService（）.createObjectDataInput（d））
.map（（r）->{
尝试
{
返回r.readUTF（）；
}捕获（IOE异常）
{
抛出新的运行时异常（e）；
}
}).collect（Collectors.toList（））；
}
@凌驾
公共无效setHazelcastInstance（HazelcastInstance HazelcastInstance）
{
hz=Hazelcast实例；
}
}
}

找到了一种有很多技巧的方法，适用于任何服务

首先运行svr，然后运行cli和测试

public class PlayHZ
{
    @Test
    public void test() throws ExecutionException, InterruptedException
    {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        IExecutorService executor = hz.getExecutorService("gather");
        Map<Member, Future<List<String>>> futures = executor.submitToAllMembers(new LockNameGather());
        Thread.sleep(1000);
        System.out.println("Found in member");
        for (Map.Entry<Member, Future<List<String>>> entry : futures.entrySet())
        {
            System.out.printf("%s -> %s\n", entry.getKey(), entry.getValue().get());
        }
    }

    @Test
    public void svr() throws InterruptedException
    {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        Thread.sleep(Integer.MAX_VALUE);
    }

    @Test
    public void cli() throws InterruptedException
    {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        for (int i = 0; i < 100; i++)
        {
            ILock lock = hz.getLock("LOCK" + i);
            lock.lock();
        }
        Thread.sleep(Integer.MAX_VALUE);
    }

    private static class LockNameGather implements Callable<List<String>>, HazelcastInstanceAware, Serializable
    {
        transient HazelcastInstance hz;
        transient NodeEngineImpl node;

        @Override
        public List<String> call() throws Exception
        {
            node = ((HazelcastInstanceImpl) hz).node.getNodeEngine();
            LockService svc = node.getService(LockService.SERVICE_NAME);

            return svc.getAllLocks()
                      .stream()
                      .map(LockResource::getKey)
                      .map(d -> node.getSerializationService().createObjectDataInput(d))
                      .map((r) -> {
                          try
                          {
                              return r.readUTF();
                          } catch (IOException e)
                          {
                              throw new RuntimeException(e);
                          }
                      }).collect(Collectors.toList());
        }

        @Override
        public void setHazelcastInstance(HazelcastInstance hazelcastInstance)
        {
            hz = hazelcastInstance;
        }
    }
}

公共类PlayHZ
{
@试验
public void test（）引发ExecutionException、InterruptedException
{
HazelcastInstance hz=Hazelcast.newHazelcastInstance（）；
IExecutorService executor=hz.getExecutorService（“收集”）；
Map futures=executor.submitToAllMembers（新的LockNameGather（））；
睡眠（1000）；
System.out.println（“在成员中找到”）；
for（Map.Entry:futures.entrySet（））
{
System.out.printf（“%s->%s\n”，entry.getKey（），entry.getValue（）.get（））；
}
}
@试验
public void svr（）引发InterruptedException
{
HazelcastInstance hz=Hazelcast.newHazelcastInstance（）；
Thread.sleep（整数.MAX_值）；
}
@试验
public void cli（）引发InterruptedException
{
HazelcastInstance hz=Hazelcast.newHazelcastInstance（）；
对于（int i=0；i<100；i++）
{
ILock lock=hz.getLock（“lock”+i）；
lock.lock（）；
}
Thread.sleep（整数.MAX_值）；
}
私有静态类LockNameGather实现可调用、HazelCastInstanceWare、可序列化
{
瞬态HazelcastInstance hz；
瞬态节点工程节点；
@凌驾
公共列表调用（）引发异常
{
node=（（HazelcastInstanceImpl）hz）.node.getNodeEngine（）；
LockService svc=node.getService（LockService.SERVICE\u名称）；
返回svc.getAllLocks（）
.stream（）
.map（LockResource:：getKey）
.map（d->node.getSerializationService（）.createObjectDataInput（d））
.map（（r）->{
尝试
{
返回r.readUTF（）；
}捕获（IOE异常）
{
抛出新的运行时异常（e）；
}
}).collect（Collectors.toList（））；
}
@凌驾
公共无效setHazelcastInstance（HazelcastInstance HazelcastInstance）
{
hz=Hazelcast实例；
}
}
}

那么你的问题与原来的问题有何不同？如果是一样的，我宁愿把这当作一个重复的问题。原来的问题不能回答这个问题，但要求是一样的，所以我应该把答案贴到原来的问题上？你发现了以前的一个问题，你说你的问题和它是一样的，而这个问题已经得到了接受的答案，那为什么那个被接受的答案不能解决你的问题呢？你必须清楚。如果情况是你有另一种方法来解决同样的问题，把它贴在原来的问题上。如果发现您的问题或要求与原来的不同，请在问题中明确说明。因为版本已更改，该问题大约是2年前的问题，答案不再有效。因此我在标题中添加了hazelcast 3.x中的

。我该怎么办？然后在你的问题中提到，类似问题中的解决方案在hazelcast 3中不再有效。如果你用公认的答案提及这个问题，而不说明为什么它不起作用，那么你的问题与原文有什么不同呢