Задержка выполнения цыкла

[ANZO]

че вы к ThreadPoolManager прицепились, от точно также слипит Триды ( разве есть другие методы сделать отложенный запуск ?).

Я про то, чтобы не расставлять костыли и дабл код. Товарищ Акванокс собственно запруфил то, что я хотел донести до ТС'а упомнинанием о TPM.

[Wolfas]

Удалив лишнее из когда, посмотрите я хоть правильно понял что нужно сделать?

Код:

package playercommands;


public class GoTo extends playerCommand {

    public GoTo() {
        super("goto");
    }

    @Override
    public void executeCommand(Player admin, String[] params) {
        if (admin.getAccessLevel() < AdminConfig.COMMAND_GOTO) {
            PacketSendUtility.sendMessage(admin, "You dont have enough rights to execute this command!");
            return;
        }


        if (params[0].toLowerCase().equals("pvp1")) {
            admin.getGameStats().setStat(StatEnum.SPEED, -2500);
            PacketSendUtility.broadcastPacket(admin, new SM_EMOTION(admin, EmotionType.START_EMOTE2, 0, 0), true);
            TeleportService.teleportTo(admin, 600010000, 831, 1040, 325, 7500);
            new delayTask().run();
        } else if (params[0].toLowerCase().equals("pvp2")) {
            admin.getGameStats().setStat(StatEnum.SPEED, -2500);
            PacketSendUtility.broadcastPacket(admin, new SM_EMOTION(admin, EmotionType.START_EMOTE2, 0, 0), true);
            TeleportService.teleportTo(admin, 600010000, 651, 1144, 323, 7500);
            new delayTask().run();
        }
    else
              PacketSendUtility.sendMessage(admin, "Такого места не существует, возможно вы ошиблись при написании.");
    }


    private class delayTask extends Thread
    {
        public void executeCommand(Player admin, String[] params)
        {
            try
            {
                Thread.sleep(750);
            }
            catch (InterruptedException e){}
                
            admin.getGameStats().setStat(StatEnum.SPEED, 6000);
            PacketSendUtility.broadcastPacket(admin, new SM_EMOTION(admin, EmotionType.START_EMOTE2, 0, 0), true);
            PacketSendUtility.sendMessage(admin, "Скорость востановлена.");
        }
    }
    
}

[bloodshed]

изжоп какой то

Добавлено через 9 минут

Код:

    private class delayTask extends Thread
    {
        public void executeCommand(Player admin, String[] params)
        {
            try
            {
                Thread.sleep(750);
            }
            catch (InterruptedException e){}
                
            admin.getGameStats().setStat(StatEnum.SPEED, 6000);
            PacketSendUtility.broadcastPacket(admin, new SM_EMOTION(admin, EmotionType.START_EMOTE2, 0, 0), true);
            PacketSendUtility.sendMessage(admin, "Скорость востановлена.");
        }
    }

Это не будет работать.

[Galaxy]

Доброго времени суток.
В общем суть задачи, необходимо установить задержку выполнения скрипта.

То есть после выполнения одной функции нужна задержка, затем выполнение следующей функции.

Пиши в скайп galaxy.entertainment - помогу.

[Smiler]

корректный метод

Код:

    public main()
    {
        new Thread(new delayTask()).start();
    }
    
    private class delayTask implements Runnable
    {
        public void run()
        {
            try
            {
                Thread.sleep(1000);
            }
            catch (InterruptedException e){}
        }
    }

[Wolfas]

в общем, выходит

Код:

public class main {

new Thread(new delayTask()).start();

}
private class delayTask extends Thread
    {
        public void run()
        {
            try
            {
                Thread.sleep(7500);
            }
            catch (InterruptedException e){}
            
            new Thread(new speedreload()).start();
        }
    }
    private class speedreload extends Thread
    {
        public void executeCommand(Player admin, String[] params)
        {
            admin.getGameStats().setStat(StatEnum.SPEED, 6000);
            PacketSendUtility.broadcastPacket(admin, new SM_EMOTION(admin, EmotionType.START_EMOTE2, 0, 0), true);
            PacketSendUtility.sendMessage(admin, "Скорость востановлена.");
        }
    }

private class speedreload не запускает

[ANZO]

Зачем Вы описание метода впихнули в раннейбл? От этого он выполнятся не станет Там должен быть вызов или содержимое метода.

и как бы

private class delayTask extends Runnable

[Wolfas]

Зачем Вы описание метода впихнули в раннейбл? От этого он выполнятся не станет Там должен быть вызов или содержимое метода.

и как бы

private class delayTask extends Runnable

Не понял, так что нужно сделать, лучше наглядно

[bloodshed]

Не понял, так что нужно сделать, лучше наглядно

не ленитесь http://b23.ru/3h9n

[Wolfas]

Разбираясь я случайно обнаружил что у меня есть ThreadPoolManager
Вот собственно он:

ThreadPoolManager

public final class ThreadPoolManager
implements DisconnectionThreadPool
{
private static final Logger log = Logger.getLogger(ThreadPoolManager.class);
public static final long MAXIMUM_RUNTIME_IN_MILLISEC_WITHOUT_WARNING = 5000L;
private static final long MAX_DELAY = TimeUnit.NANOSECONDS.toMillis(9223372036854775807L - System.nanoTime()) / 2L;
private final ScheduledThreadPoolExecutor scheduledPool;
private final ThreadPoolExecutor instantPool;
private final ThreadPoolExecutor longRunningPool;
private final ScheduledThreadPoolExecutor disconnectionScheduledThreadPool;

public static ThreadPoolManager getInstance()
{
return SingletonHolder.INSTANCE;
}

private ThreadPoolManager()
{
int instantPoolSize = Math.max(1, ThreadConfig.THREAD_POOL_SIZE / 3);

this.scheduledPool = new ScheduledThreadPoolExecutor(ThreadConfig.THREAD_POOL_SIZE - instantPoolSize);
this.scheduledPool.setRejectedExecutionHandler(new AionRejectedExecutionHandler());
this.scheduledPool.prestartAllCoreThreads();

this.instantPool = new ThreadPoolExecutor(instantPoolSize, instantPoolSize, 0L, TimeUnit.SECONDS, new ArrayBlockingQueue(100000));

this.instantPool.setRejectedExecutionHandler(new AionRejectedExecutionHandler());
this.instantPool.prestartAllCoreThreads();

this.longRunningPool = new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());

this.longRunningPool.setRejectedExecutionHandler(new AionRejectedExecutionHandler());
this.longRunningPool.prestartAllCoreThreads();

this.disconnectionScheduledThreadPool = new ScheduledThreadPoolExecutor(4);
this.disconnectionScheduledThreadPool.setRejectedExecutionHandler(new AionRejectedExecutionHandler());
this.disconnectionScheduledThreadPool.prestartAllCoreThreads();

scheduleAtFixedRate(new Runnable()
{
public void run()
{
ThreadPoolManager.this.purge();
}
}
, 60000L, 60000L);

log.info("ThreadPoolManager: Initialized with " + this.scheduledPool.getPoolSize() + " scheduler, " + this.instantPool.getPoolSize() + " instant, " + this.longRunningPool.getPoolSize() + " long, " + this.disconnectionScheduledThreadPool.getPoolSize() + " disconnection running thread(s).");
}

private final long validate(long delay)
{
return Math.max(0L, Math.min(MAX_DELAY, delay));
}

public final ScheduledFuture<?> schedule(Runnable r, long delay)
{
r = new ThreadPoolExecuteWrapper®;
delay = validate(delay);

return new ScheduledFutureWrapper(this.scheduledPool.schedule(r, delay, TimeUnit.MILLISECONDS));
}

public final ScheduledFuture<?> scheduleEffect(Runnable r, long delay)
{
return schedule(r, delay);
}

public final ScheduledFuture<?> scheduleGeneral(Runnable r, long delay)
{
return schedule(r, delay);
}

public final ScheduledFuture<?> scheduleAi(Runnable r, long delay)
{
return schedule(r, delay);
}

public final ScheduledFuture<?> scheduleAtFixedRate(Runnable r, long delay, long period)
{
r = new ThreadPoolExecuteWrapper®;
delay = validate(delay);
period = validate(period);

return new ScheduledFutureWrapper(this.scheduledPool.scheduleAtFixedRate(r, delay, period, TimeUnit.MILLISECONDS));
}

public final ScheduledFuture<?> scheduleEffectAtFixedRate(Runnable r, long delay, long period)
{
return scheduleAtFixedRate(r, delay, period);
}

public final ScheduledFuture<?> scheduleGeneralAtFixedRate(Runnable r, long delay, long period)
{
return scheduleAtFixedRate(r, delay, period);
}

public final ScheduledFuture<?> scheduleAiAtFixedRate(Runnable r, long delay, long period)
{
return scheduleAtFixedRate(r, delay, period);
}

public final void execute(Runnable r)
{
r = new ThreadPoolExecuteWrapper®;

this.instantPool.execute®;
}

public final void executeTask(Runnable r)
{
execute®;
}

public final void executeInterruptable(InterruptableTask r)
{
execute®;
}

public final void executeLongRunning(Runnable r)
{
r = new ExecuteWrapper®;

this.longRunningPool.execute®;
}

public final Future<?> submit(Runnable r)
{
r = new ThreadPoolExecuteWrapper®;

return this.instantPool.submit®;
}

public final Future<?> submitInterruptable(InterruptableTask r)
{
return this.instantPool.submit®;
}

public final Future<?> submitLongRunning(Runnable r)
{
r = new ExecuteWrapper®;

return this.longRunningPool.submit®;
}

public void executeLsPacket(Runnable pkt)
{
execute(pkt);
}

public final void scheduleDisconnection(DisconnectionTask dt, long delay)
{
schedule(dt, delay);
}

public void waitForDisconnectionTasks()
{
try
{
this.disconnectionScheduledThreadPool.shutdown();
this.disconnectionScheduledThreadPool.awaitTermination(6L, TimeUnit.MINUTES);
}
catch (Exception e)
{
}
}

public ScheduledFuture<?> scheduleTaskManager(Runnable r, long delay)
{
return schedule(r, delay);
}

public void purge()
{
this.scheduledPool.purge();
this.instantPool.purge();
this.longRunningPool.purge();
this.disconnectionScheduledThreadPool.purge();
}

public void shutdown()
{
long begin = System.currentTimeMillis();

log.info("ThreadPoolManager: Shutting down.");
log.info("\t... executing " + getTaskCount(this.scheduledPool) + " scheduled tasks.");
log.info("\t... executing " + getTaskCount(this.instantPool) + " instant tasks.");
log.info("\t... executing " + getTaskCount(this.longRunningPool) + " long running tasks.");

this.scheduledPool.shutdown();
this.instantPool.shutdown();
this.longRunningPool.shutdown();

boolean success = false;
try
{
success |= awaitTermination(5000L);

this.scheduledPool.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
this.scheduledPool.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);

success |= awaitTermination(10000L);
}
catch (InterruptedException e)
{
e.printStackTrace();
}

log.info("\t... success: " + success + " in " + (System.currentTimeMillis() - begin) + " msec.");
log.info("\t... " + getTaskCount(this.scheduledPool) + " scheduled tasks left.");
log.info("\t... " + getTaskCount(this.instantPool) + " instant tasks left.");
log.info("\t... " + getTaskCount(this.longRunningPool) + " long running tasks left.");
}

private int getTaskCount(ThreadPoolExecutor tp)
{
return tp.getQueue().size() + tp.getActiveCount();
}

public List<String> getStats()
{
List list = new ArrayList();

list.add("");
list.add("Scheduled pool:");
list.add("=================================================");
list.add("\tgetActiveCount: ...... " + this.scheduledPool.getActiveCount());
list.add("\tgetCorePoolSize: ..... " + this.scheduledPool.getCorePoolSize());
list.add("\tgetPoolSize: ......... " + this.scheduledPool.getPoolSize());
list.add("\tgetLargestPoolSize: .. " + this.scheduledPool.getLargestPoolSize());
list.add("\tgetMaximumPoolSize: .. " + this.scheduledPool.getMaximumPoolSize());
list.add("\tgetCompletedTaskCount: " + this.scheduledPool.getCompletedTaskCount());
list.add("\tgetQueuedTaskCount: .. " + this.scheduledPool.getQueue().size());
list.add("\tgetTaskCount: ........ " + this.scheduledPool.getTaskCount());
list.add("");
list.add("Instant pool:");
list.add("=================================================");
list.add("\tgetActiveCount: ...... " + this.instantPool.getActiveCount());
list.add("\tgetCorePoolSize: ..... " + this.instantPool.getCorePoolSize());
list.add("\tgetPoolSize: ......... " + this.instantPool.getPoolSize());
list.add("\tgetLargestPoolSize: .. " + this.instantPool.getLargestPoolSize());
list.add("\tgetMaximumPoolSize: .. " + this.instantPool.getMaximumPoolSize());
list.add("\tgetCompletedTaskCount: " + this.instantPool.getCompletedTaskCount());
list.add("\tgetQueuedTaskCount: .. " + this.instantPool.getQueue().size());
list.add("\tgetTaskCount: ........ " + this.instantPool.getTaskCount());
list.add("");
list.add("Long running pool:");
list.add("=================================================");
list.add("\tgetActiveCount: ...... " + this.longRunningPool.getActiveCount());
list.add("\tgetCorePoolSize: ..... " + this.longRunningPool.getCorePoolSize());
list.add("\tgetPoolSize: ......... " + this.longRunningPool.getPoolSize());
list.add("\tgetLargestPoolSize: .. " + this.longRunningPool.getLargestPoolSize());
list.add("\tgetMaximumPoolSize: .. " + this.longRunningPool.getMaximumPoolSize());
list.add("\tgetCompletedTaskCount: " + this.longRunningPool.getCompletedTaskCount());
list.add("\tgetQueuedTaskCount: .. " + this.longRunningPool.getQueue().size());
list.add("\tgetTaskCount: ........ " + this.longRunningPool.getTaskCount());
list.add("");
list.add("");
list.add("Disconnection running pool:");
list.add("=================================================");
list.add("\tgetActiveCount: ...... " + this.disconnectionScheduledThreadPool.getActiveCount());
list.add("\tgetCorePoolSize: ..... " + this.disconnectionScheduledThreadPool.getCorePoolSize());
list.add("\tgetPoolSize: ......... " + this.disconnectionScheduledThreadPool.getPoolSize());
list.add("\tgetLargestPoolSize: .. " + this.disconnectionScheduledThreadPool.getLargestPoolSize());
list.add("\tgetMaximumPoolSize: .. " + this.disconnectionScheduledThreadPool.getMaximumPoolSize());
list.add("\tgetCompletedTaskCount: " + this.disconnectionScheduledThreadPool.getCompletedTaskCount());
list.add("\tgetQueuedTaskCount: .. " + this.disconnectionScheduledThreadPool.getQueue().size());
list.add("\tgetTaskCount: ........ " + this.disconnectionScheduledThreadPool.getTaskCount());
list.add("");

return list;
}

private boolean awaitTermination(long timeoutInMillisec) throws InterruptedException
{
long begin = System.currentTimeMillis();

while (System.currentTimeMillis() - begin < timeoutInMillisec)
{
if (((this.scheduledPool.awaitTermination(10L, TimeUnit.MILLISECONDS)) || (this.scheduledPool.getActiveCount() <= 0)) &&
((this.instantPool.awaitTermination(10L, TimeUnit.MILLISECONDS)) || (this.instantPool.getActiveCount() <= 0)) && (
(this.longRunningPool.awaitTermination(10L, TimeUnit.MILLISECONDS)) || (this.longRunningPool.getActiveCount() <= 0)))
{
return true;
}
}
return false;
}

private static final class ThreadPoolExecuteWrapper extends ExecuteWrapper
{
public ThreadPoolExecuteWrapper(Runnable runnable)
{
super();
}

protected long getMaximumRuntimeInMillisecWithoutWarning()
{
return ThreadConfig.MAXIMUM_RUNTIME_IN_MILLISEC_WITHOUT_WARNING;
}
}

private static final class SingletonHolder
{
private static final ThreadPoolManager INSTANCE = new ThreadPoolManager(null);
}
}

Как там задержку написать при его помощи?