import org.infinispan.distexec.DefaultExecutorService; //导入依赖的package包/类
public static void main(String[] args) {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Make the default cache a distributed one
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.clustering().cacheMode(CacheMode.DIST_SYNC);
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build(), builder.build());
   // Obtain the default cache
   Cache<String, String> cache = cacheManager.getCache();
   // Create a distributed executor service using the distributed cache to determine the nodes on which to run
   DefaultExecutorService executorService = new DefaultExecutorService(cache);
   // Submit a job to all nodes
   List<Future<Integer>> results = executorService.submitEverywhere((Callable & Serializable) () -> new Random().nextInt());
   // Print out the results
   results.forEach(s -> {
      try {
         System.out.printf("%s\n", s.get(100, TimeUnit.MILLISECONDS));
      } catch (Exception e) {
      }
   });
   // Shuts down the cache manager and all associated resources
   cacheManager.stop();
   System.exit(0);
}
 

import org.infinispan.distexec.DefaultExecutorService; //导入依赖的package包/类
@Override
public List<Future<Long>> submitDistributable(String cacheName,
                                              Callable<Long> callable,
                                              String... keys)
{
    Cache c = getCache(cacheName);

    DistributedExecutorService des  = new DefaultExecutorService(c);

    return des.submitEverywhere(callable, keys);

    // TODO executors will probably leak, find a better solution where I shut down an
    // executor that is not in use anymore.
}
 

import org.infinispan.distexec.DefaultExecutorService; //导入依赖的package包/类
@Override
public void execute() throws Exception
{
    Cache c = ca.getCache("SOURCE-CACHE");

    DistributedExecutorService des = new DefaultExecutorService(c);

    Callable callable = new ExampleDistributedCallable();
    //Callable<String> callable = new ExampleCallable<String>();

    List<Future<DistributedCallableResponse>> results = null;

    if (submitEverywhere)
    {
        if (keys.isEmpty())
        {
            System.out.println("> submitting everywhere, no input keys");
            results = des.submitEverywhere(callable);
            System.out.println("> submission everywhere, no input keys, ok");
        }
        else
        {
            results = des.submitEverywhere(callable, keys);
            System.out.println("> submission to all nodes ok, key set " + keys);
        }
    }
    else
    {
        Future<DistributedCallableResponse> result = des.submit(callable, keys);
        System.out.println("> submission to one node ok, key set " + keys);
        results = Arrays.asList(result);
    }

    for (Future<DistributedCallableResponse> f : results)
    {
        System.out.println("> got response from " + f.get().getNodeName());
    }

    System.out.println("> execution ok");
}
 

import org.infinispan.distexec.DefaultExecutorService; //导入依赖的package包/类
public List<Future> rot(int offset) {
    DistributedExecutorService des = new DefaultExecutorService(cache);
    return des.submitEverywhere(new Rotate(offset));
}