Java SpongeExecutorService类代码示例

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    int page = args.<Integer>getOne("page").get();

    Consumer<Collection<PlayerStats>> callback = map -> displayConsole(page, map);
    if (src instanceof Player) {
        UUID uuid = ((Player) src).getUniqueId();
        callback = map -> Sponge.getServer().getPlayer(uuid).ifPresent(player -> display(player, page, map));
    }

    SpongeExecutorService asyncExecutor = Sponge.getScheduler().createAsyncExecutor(plugin);
    SpongeExecutorService syncExecutor = Sponge.getScheduler().createAsyncExecutor(plugin);
    CompletableFuture.supplyAsync(() -> plugin.getDatabaseManager().getTopEntries(page), asyncExecutor)
            .thenAcceptAsync(callback, syncExecutor);

    src.sendMessage(Text.of(TextColors.YELLOW, "Query sent"));
    return CommandResult.success();
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    String username = args.<String>getOne("account").get();
    if (plugin.isValidName(username)) {
        SpongeExecutorService asyncExecutor = Sponge.getScheduler().createAsyncExecutor(plugin);
        SpongeExecutorService syncExecutor = Sponge.getScheduler().createAsyncExecutor(plugin);

        Optional<UUID> sender = Optional.empty();
        if (src instanceof Player) {
            sender = Optional.of(((Player) src).getUniqueId());
        }

        Optional<UUID> finalSender = sender;
        CompletableFuture.supplyAsync(() -> plugin.getDatabase().loadAccount(username), asyncExecutor)
                                .thenAcceptAsync(optAcc -> onAccLoaded(finalSender, optAcc), syncExecutor);

        return CommandResult.success();
    }

    src.sendMessage(settings.getText().getInvalidUsername());
    return CommandResult.success();
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public static UUID start(SurvivalGame survivalGame, String intervalName, int intervalSeconds) {

        SpongeExecutorService.SpongeFuture future =
                SurvivalGamesPlugin.EXECUTOR.scheduleAtFixedRate(
                        () ->
                                Sponge.getEventManager()
                                        .post(new IntervalEvent(survivalGame, intervalName)),
                        0,
                        intervalSeconds,
                        TimeUnit.SECONDS);

        UUID uuid = UUID.randomUUID();
        FUTURE_MAP.put(uuid, future);
        return uuid;
    }
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public static UUID start(SurvivalGame survivalGame, MobSpawnArea mobSpawnArea, World world) {
    int millisecondsPerSpawn =
            mobSpawnArea.getSpawnRatePerMinute().map(integer -> 1000 * 60 / integer).orElse(0);

    SpongeExecutorService.SpongeFuture future =
            SurvivalGamesPlugin.EXECUTOR.scheduleAtFixedRate(
                    new MobSpawnRunnable(survivalGame, mobSpawnArea, world),
                    0,
                    millisecondsPerSpawn,
                    TimeUnit.MILLISECONDS);

    FUTURE_MAP.put(mobSpawnArea.getId(), future);

    return mobSpawnArea.getId();
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public SpongeExecutorService getExecutor() {
    if (this.executor == null) {
        this.executor = Sponge.getScheduler().createSyncExecutor(this);
    }
    return this.executor;
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public SpongeExecutorService getSyncExecutorService() {
    return this.syncExecutorService;
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public SpongeExecutorService getAsyncExecutorService() {
    return this.asyncExecutorService;
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
@Override
public SpongeExecutorService getThreadAsync() {
	return this.threadAsync;
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public SpongeExecutorService getThreadSync() {
	return this.threadSync;
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public SpongeExecutorService getThreadAsync() {
	return this.getEverAPI().getThreadAsync();
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public SpongeExecutorService getThreadSync() {
	return this.getEverAPI().getThreadSync();
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
public static SpongeExecutorService getSyncExecutorService() {
    return LanternGame.game.getSyncExecutorService();
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
@Override
public SpongeExecutorService createSyncExecutor(Object plugin) {
    return new TaskExecutorService(this::createTaskBuilder, this.syncScheduler, checkPlugin(plugin, "plugin"));
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
@Override
public SpongeExecutorService createAsyncExecutor(Object plugin) {
    return new TaskExecutorService(() -> createTaskBuilder().async(), this.asyncScheduler, checkPlugin(plugin, "plugin"));
}
 

import org.spongepowered.api.scheduler.SpongeExecutorService; //导入依赖的package包/类
@Override
public SpongeExecutorService get() {
    return this.scheduler.createSyncExecutor(this.container);
}