How to use

getExecutorService

method

in

org.redisson.api.RedissonClient

public MapReduceExecutor(RObject object, RedissonClient redisson, ConnectionManager connectionManager) {
  this.objectName = object.getName();
  this.objectCodec = object.getCodec();
  this.objectClass = object.getClass();
  this.redisson = redisson;
  UUID id = UUID.randomUUID();
  this.resultMapName = object.getName() + ":result:" + id;
  this.executorService = redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME);
  this.connectionManager = connectionManager;
}

public MapReduceExecutor(RObject object, RedissonClient redisson, ConnectionManager connectionManager) {
  this.objectName = object.getName();
  this.objectCodec = object.getCodec();
  this.objectClass = object.getClass();
  this.redisson = redisson;
  UUID id = UUID.randomUUID();
  this.resultMapName = object.getName() + ":result:" + id;
  this.executorService = redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME);
  this.connectionManager = connectionManager;
}

  mapReduceWorkers = Runtime.getRuntime().availableProcessors();
redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME).registerWorkers(mapReduceWorkers);
log.info("{} map reduce worker(s) registered", mapReduceWorkers);
String name = entry.getKey();
int workers = entry.getValue();
redisson.getExecutorService(name).registerWorkers(workers);
log.info("{} worker(s) for '{}' ExecutorService registered", workers, name);

  mapReduceWorkers = Runtime.getRuntime().availableProcessors();
redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME).registerWorkers(mapReduceWorkers);
log.info("{} map reduce worker(s) registered", mapReduceWorkers);
String name = entry.getKey();
int workers = entry.getValue();
redisson.getExecutorService(name).registerWorkers(workers);
log.info("{} worker(s) for '{}' ExecutorService registered", workers, name);

RScheduledExecutorService executor = redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME);
int workersAmount = executor.countActiveWorkers();

RScheduledExecutorService executor = redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME);
int workersAmount = executor.countActiveWorkers();

public MapReduceExecutor(RObject object, RedissonClient redisson, ConnectionManager connectionManager) {
  this.objectName = object.getName();
  this.objectCodec = object.getCodec();
  this.objectClass = object.getClass();
  this.redisson = redisson;
  UUID id = UUID.randomUUID();
  this.resultMapName = object.getName() + ":result:" + id;
  this.executorService = redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME);
  this.connectionManager = connectionManager;
}

@Override
public void publish(Event event) {
 redissonClient.getExecutorService(JobConfig.EVENT).execute(new EventExecuteWrapper(event));
}

@Override
public void pauseJob(String jobId) {
 RListMultimap<String, String> listmap = getRedissonClient().getListMultimap(JobConfig.TASK_ID);
 RScheduledExecutorService service = getRedissonClient().getExecutorService(JobConfig.WORKER);
 Iterator<String> it = listmap.get(jobId).iterator();
 while (it.hasNext()) {
  String id = it.next();
  service.cancelTask(id);
  it.remove();
 }
}

@Override
public int count(JobExecuteParam param) {
 int workers = redissonClient.getExecutorService(param.getTopicKey()).countActiveWorkers();
 if (workers == 0) {
  throw Exceptions.fail("30000", "没有可调度的执行器");
 }
 return workers;
}

@Override
public void triggerJob(String jobId) {
 getRedissonClient().getExecutorService(JobConfig.WORKER).submit(new JobDispatchWrapper(jobId));
}

@Override
public String addSimpleJob(String jobId, long timestamp) {
 String taskId = getRedissonClient().getExecutorService(JobConfig.WORKER)
   .scheduleAsync(new JobDispatchWrapper(jobId),
     timestamp - ZonedDateTime.now().toInstant().toEpochMilli(), TimeUnit.MILLISECONDS)
   .getTaskId();
 getRedissonClient().<String, String>getListMultimap(JobConfig.TASK_ID).put(jobId, taskId);
 return taskId;
}

@Override
public void retryJob(String jobId, String loggerId, String parentLoggerId) {
 JobDispatchWrapper wrapper = new JobDispatchWrapper(jobId, loggerId);
 wrapper.setParentLoggerId(parentLoggerId);
 getRedissonClient().getExecutorService(JobConfig.WORKER).submit(wrapper);
}

@Override
public void triggerChildJob(String jobId, String loggerId) {
 JobDispatchWrapper wrapper = new JobDispatchWrapper(jobId);
 wrapper.setParentLoggerId(loggerId);
 getRedissonClient().getExecutorService(JobConfig.WORKER).submit(wrapper);
}

@Override
public void dispatch(JobExecuteParam param) {
 JobInfo jobInfo = jobRepository.findJobInfoById(param.getJobId());
 if (jobInfo == null) {
  throw Exceptions.fail("30005", String.format("未查询到任务 %s", param));
 }
 this.checkDispatch(param);
 if (Objects.equals(JobInfo.TYPE.SCRIPT.name(), jobInfo.getType())) {
  redissonClient.getExecutorService(param.getTopicKey())
    .execute(new JobScriptExecuteWrapper(param));
 } else {
  redissonClient.getExecutorService(param.getTopicKey())
    .execute(new JobBeanExecuteWrapper(param));
 }
}

 @PostConstruct
 public void initCenter() {
  Bootstrap.start();
  RedissonClient redissonClient = BeanStore.getBean(RedissonClient.class);
  JobRepository jobRepository = BeanStore.getBean(JobRepository.class);
  // schedule
  BeanStore.putBean(RedisJobScheduleImpl.class.getName(), new RedisJobScheduleImpl());
  // dispatcher
  BeanStore.putBean(RedisDispatcher.class.getName(),
    new RedisDispatcher(redissonClient, jobRepository));
  redissonClient.getExecutorService(JobConfig.EVENT)
    .registerWorkers(ConfigFactory.load(SystemProperties.class).getWorkers());
  BeanStore.putBean(EventListener.class.getName(), new EventListener(notifier));
 }
}

@Override
public String addDelayJob(String jobId, long initDelay, long delay) {
 String taskId = getRedissonClient().getExecutorService(JobConfig.WORKER)
   .scheduleAtFixedRateAsync(new JobDispatchWrapper(jobId), initDelay, delay, TimeUnit.SECONDS)
   .getTaskId();
 getRedissonClient().<String, String>getListMultimap(JobConfig.TASK_ID).put(jobId, taskId);
 return taskId;
}

@Override
public String addCronJob(String jobId, String cron) {
 String taskId = getRedissonClient().getExecutorService(JobConfig.WORKER)
   .scheduleAsync(new JobDispatchWrapper(jobId), CronSchedule.of(cron)).getTaskId();
 getRedissonClient().<String, String>getListMultimap(
   JobConfig.TASK_ID).put(jobId, taskId);
 return taskId;
}

public RedisJobScheduleImpl() {
 SystemProperties props = ConfigFactory.load(SystemProperties.class);
 getRedissonClient().getExecutorService(JobConfig.WORKER)
   .registerWorkers(JobConfig.getParallel(), ThreadUtils
     .newThreadPool(props.getCorePoolSize(), props.getMaximumPoolSize(),
       props.getKeepAliveTime(), props.getQueueCapacity(), "redisson-executor-pool-%d"));
}

public static void main(String[] args) {
  Config config = new Config();
  config.useClusterServers()
    .addNodeAddress("127.0.0.1:7001", "127.0.0.1:7002", "127.0.0.1:7003");
  
  RedissonClient redisson = Redisson.create(config);
  RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
  nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("myExecutor", 1));
  RedissonNode node = RedissonNode.create(nodeConfig);
  node.start();
  RExecutorService e = redisson.getExecutorService("myExecutor");
  e.execute(new RunnableTask());
  e.submit(new CallableTask());
  
  e.shutdown();
  node.shutdown();
}