Java приостановить выполнение метода

Метод thread sleep в Java – задержка по времени

Метод Thread.sleep() можно использовать для приостановки выполнения текущего потока на указанное время в миллисекундах. Значение аргумента в миллисекундах не может быть отрицательным, иначе оно выдает исключение IllegalArgumentException.

Существует еще один метод sleep(long millis, int nanos), который можно использовать для приостановки выполнения текущего потока на указанные миллисекунды и наносекунды. Допустимое значение nano second составляет от 0 до 999999.

InterruptedException возникает, если какой-либо поток прервал текущий поток. Прерванное состояние текущего потока очищается при возникновении этого исключения.

public static void sleep(long millis) throws InterruptedException

Как работает Thread Sleep?

Thread.sleep() взаимодействует с планировщиком потока, чтобы перевести текущий поток в состояние ожидания в течение указанного периода времени. По истечении времени, ожидания состояние потока изменяется на работоспособное состояние и ожидает ЦП для дальнейшего выполнения.

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

Пример thread sleep на Java

Вот простая программа на Java, в которой Thread.sleep() используется для задержки по времени основного потока на 2 секунды.

package com.journaldev.threads; public class ThreadSleep < public static void main(String[] args) throws InterruptedException < long start = System.currentTimeMillis(); Thread.sleep(2000); System.out.println("Sleep time in ms EnlighterJSRAW" data-enlighter-language="java" data-enlighter-theme="eclipse">package com.tutorial; import java.lang.*; public class ThreadDemo implements Runnable < Thread t; public void run() < for (int i = 10; i < 13; i++) < System.out.println(Thread.currentThread().getName() + " " + i); try < // в течение 1000 миллисекунд Thread.sleep(1000); >catch (Exception e) < System.out.println(e); >> > public static void main(String[] args) throws Exception < Thread t = new Thread(new ThreadDemo()); // this will call run() function t.start(); Thread t2 = new Thread(new ThreadDemo()); // this will call run() function t2.start(); >>

Давайте скомпилируем и запустим программу, это даст следующий результат:
Thread-0 10
Thread-1 10
Thread-0 11
Thread-1 11
Thread-0 12
Thread-1 12

Средняя оценка 4.1 / 5. Количество голосов: 10

Спасибо, помогите другим — напишите комментарий, добавьте информации к статье.

Видим, что вы не нашли ответ на свой вопрос.

Напишите комментарий, что можно добавить к статье, какой информации не хватает.

Источник

Pausing Execution with Sleep

Thread.sleep causes the current thread to suspend execution for a specified period. This is an efficient means of making processor time available to the other threads of an application or other applications that might be running on a computer system. The sleep method can also be used for pacing, as shown in the example that follows, and waiting for another thread with duties that are understood to have time requirements, as with the SimpleThreads example in a later section.

Two overloaded versions of sleep are provided: one that specifies the sleep time to the millisecond and one that specifies the sleep time to the nanosecond. However, these sleep times are not guaranteed to be precise, because they are limited by the facilities provided by the underlying OS. Also, the sleep period can be terminated by interrupts, as we’ll see in a later section. In any case, you cannot assume that invoking sleep will suspend the thread for precisely the time period specified.

The SleepMessages example uses sleep to print messages at four-second intervals:

public class SleepMessages < public static void main(String args[]) throws InterruptedException < String importantInfo[] = < "Mares eat oats", "Does eat oats", "Little lambs eat ivy", "A kid will eat ivy too" >; for (int i = 0; i < importantInfo.length; i++) < //Pause for 4 seconds Thread.sleep(4000); //Print a message System.out.println(importantInfo[i]); >> >

Notice that main declares that it throws InterruptedException . This is an exception that sleep throws when another thread interrupts the current thread while sleep is active. Since this application has not defined another thread to cause the interrupt, it doesn’t bother to catch InterruptedException .

Источник

How to pause the code execution in Java

Sometimes you want to pause the execution of your Java code for a fixed number of milliseconds or seconds until another task is finished. There are multiple ways to achieve this.

The quickest way to stop the code execution in Java is to instruct the current thread to sleep for a certain amount of time. This is done by calling the Thread.sleep() static method:

try  System.out.printf("Start Time: %s\n", LocalTime.now()); Thread.sleep(2 * 1000); // Wait for 2 seconds System.out.printf("End Time: %s\n", LocalTime.now()); > catch (InterruptedException e)  e.printStackTrace(); > 

The code above stops the execution of the current thread for 2 seconds (or 2,000 milliseconds) using the Thread.sleep() method. Also, notice the try. catch block to handle InterruptedException . It is used to catch the exception when another thread interrupts the sleeping thread. This exception handling is necessary for a multi-threaded environment where multiple threads are running in parallel to perform different tasks.

For better readability, you can also use the TimeUnit.SECONDS.sleep() method to pause a Java program for a specific number of seconds as shown below:

try  System.out.printf("Start Time: %s\n", LocalTime.now()); TimeUnit.SECONDS.sleep(2); // Wait 2 seconds System.out.printf("End Time: %s\n", LocalTime.now()); > catch (InterruptedException e)  e.printStackTrace(); > 

Under the hood, the TimeUnit.SECONDS.sleep() method also calls the Thread.sleep() method. The only difference is readability that makes the code easier to understand for unclear durations. The TimeUnit is not just limited to seconds. It also provides methods for other time units such as nanoseconds, microseconds, milliseconds, minutes, hours, and days:

// Wait 500 nanoseconds TimeUnit.NANOSECONDS.sleep(500); // Wait 5000 microseconds TimeUnit.MICROSECONDS.sleep(5000); // Wait 500 milliseconds TimeUnit.MILLISECONDS.sleep(500); // Wait 5 minutes TimeUnit.MINUTES.sleep(5); // Wait 2 hours TimeUnit.HOURS.sleep(2); // Wait 1 day TimeUnit.DAYS.sleep(1); 

The sleep times are inaccurate with Thread.sleep() when you use smaller time increments like nanoseconds, microseconds, or milliseconds. This is especially true when used inside a loop. For every iteration of the loop, the sleep time will drift slightly due to other code execution and become completely imprecise after some iterations. For more robust and precise code execution delays, you should use the ScheduledExecutorService interface instead. This interface can schedule commands to run after a given delay or at a fixed time interval. For example, to run the timer() method after a fixed delay, you use the schedule() method:

public class Runner  public static void main(String[] args)  ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); // Execute timer after 2 seconds service.schedule(Runner::timer, 2, TimeUnit.SECONDS); > public static void timer()  System.out.println("Current time: " + LocalTime.now()); > > 

Similarly, to call the method timer() every second, you should use the scheduleAtFixedRate() method as shown below:

public class Runner  public static void main(String[] args)  ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); // Execute timer every second service.scheduleAtFixedRate(Runner::timer, 0, 1, TimeUnit.SECONDS); > public static void timer()  System.out.println("Current time: " + LocalTime.now()); > > 

Current time: 08:48:11.350034 Current time: 08:48:12.335319 Current time: 08:48:13.337250 Current time: 08:48:14.334107 Current time: 08:48:15.338532 Current time: 08:48:16.336175 ... 

You might also like.

Источник

Как задержать выполнение кода на Java

Относительно часто программы Java добавляют задержку или паузу в свою работу. Это может быть полезно для ускорения выполнения задачи или для приостановки выполнения до завершения другой задачи.

В этом руководстве будут описаны два способа реализации задержек в Java.

2. Подход, Основанный На Потоках

Когда запускается программа Java, она порождает процесс , который выполняется на хост-машине. Этот процесс содержит по крайней мере один поток – основной поток – в котором выполняется программа. Кроме того, Java позволяет многопоточность , что позволяет приложениям создавать новые потоки, которые выполняются параллельно или асинхронно с основным потоком.

2.1. Использование Thread.sleep

Быстрый и грязный способ приостановки в Java-это указать текущему потоку, чтобы он спал в течение определенного периода времени. Это можно сделать с помощью Thread.sleep(миллисекунды) :

try < Thread.sleep(secondsToSleep * 1000); >catch (InterruptedException ie)

Рекомендуется обернуть метод sleep в блок try/catch на случай, если другой поток прерывает спящий поток. В этом случае мы перехватываем исключение InterruptedException и явно прерываем текущий поток, чтобы его можно было перехватить позже и обработать. Это более важно в многопоточной программе, но все же хорошая практика в однопоточной программе на случай, если мы добавим другие потоки позже.

2.2. Использование TimeUnit.sleep

Для лучшей читаемости мы можем использовать TimeUnit.XXX.sleep(y) , Где XXX – единица времени для сна ( СЕКУНДЫ , МИНУТЫ и т. Д.), А y – номер этой единицы для сна. Это использует Thread.sleep за кулисами. Вот пример синтаксиса Единицы времени :

try < TimeUnit.SECONDS.sleep(secondsToSleep); >catch (InterruptedException ie)

Однако есть некоторые недостатки в использовании этих методов на основе потоков :

• Время сна не совсем точно, особенно при использовании меньших временных приращений, таких как миллисекунды и наносекунды
• При использовании внутри циклов сон будет немного смещаться между итерациями цикла из-за выполнения другого кода, поэтому время выполнения может стать неточным после многих итераций

3. Подход, Основанный На ExecutorService

Java предоставляет интерфейс ScheduledExecutorService, который является более надежным и точным решением. Этот интерфейс может запланировать выполнение кода один раз после указанной задержки или через фиксированные интервалы времени.

Чтобы запустить фрагмент кода один раз после задержки, мы можем использовать метод schedule :

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(); executorService.schedule(Classname::someTask, delayInSeconds, TimeUnit.SECONDS);

Имя класса :: некоторая задача часть, в которой мы указываем метод, который будет выполняться после задержки:

• некоторая задача – это имя метода, который мы хотим выполнить
• Имя класса – это имя класса, содержащего ту же задачу метод

Для выполнения задачи с фиксированными интервалами времени мы можем использовать метод scheduleAtFixedRate :

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(); executorService.scheduleAtFixedRate(Classname::someTask, 0, delayInSeconds, TimeUnit.SECONDS);

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

Кроме того, позволяя больше вариантов синхронизации, метод ScheduledExecutorService дает более точные временные интервалы, так как он предотвращает проблемы с дрейфом.

4. Заключение

В этой статье мы обсудили два метода создания задержек в программах Java.

Полный код этой статьи можно найти на Github . Это проект на основе Maven, поэтому его должно быть легко импортировать и запускать как есть.

Читайте ещё по теме:

Источник