Thread sleep 1000 java

Java.lang.Thread.sleep() Method

The java.lang.Thread.sleep(long millis) method causes the currently executing thread to sleep for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.

Declaration

Following is the declaration for java.lang.Thread.sleep() method

public static void sleep(long millis) throws InterruptedException

Parameters

millis − This is the length of time to sleep in milliseconds.

Return Value

This method does not return any value.

Exception

InterruptedException − if any thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.

Example

The following example shows the usage of java.lang.Thread.sleep() method.

package com.tutorialspoint; 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 < // thread to sleep for 1000 milliseconds 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(); >>

Let us compile and run the above program, this will produce the following result −

Thread-0 10 Thread-1 10 Thread-0 11 Thread-1 11 Thread-0 12 Thread-1 12

Источник

Метод 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

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

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

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

Источник

Thread sleep 1000 java

почему мы еще раз проверяем отработала ли первая нить , если вторая должна запуститься после завершения первой нити ?

Как посмотреть все статьи данного автора? А то написано «Давай вспомним пример из предыдущей лекции» а где эту лекцию найти хз

Зачем проверка isInterrupted в while (!current.isInterrupted()) ? Если использовать while (true), то в Thread.sleep все равно будет проверка и выброс InterruptedException.

Цитата: «Давай вернемся к примеру с часами, который был в лекции основного курса.» Что за «основной курс»?

Конечно я и сам не оратор, но смотреть этот ролик невозможно : ээ, эмм, вот, так вот, вот — тот еще мямля. Простите но это просто не качественный контент разжиженый водичкой . Еще с красным маркером , едва видным, по белому холсту, ужас.

Дело в том, что прямой вызов метода run() не имеет отношения к многопоточности. В этом случае программа будет выполнена в главном потоке — том, в котором выполняется метод main(). Он просто последовательно выведет 10 строк на консоль и все. Никакие 10 потоков не запустятся. Почему же тогда метод getName() выдает 10 разных значений? Откуда 10 разных имён потоков, если всё выполняется в главном потоке? Кто-то может объяснить? Попробовал переписать код с имплементацией Runnable вместо наследования Thread:

 public class MainRunnable < public static void main(String[] args) < for (int i = 0; i < 10; i++) < Thread thread = new Thread(new mulithreading.MyFirstThread2()); thread.run(); >> > class MyFirstThread2 implements Runnable < @Override public void run() < System.out.println("Выполнен поток " + Thread.currentThread().getName()); >> 

 Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main Выполнен поток main 

ВНИМАНИЕ, ВОПРОС! Зачем в методе run в цикле while с условием !current.isInterrupted() при выкидывании InterruptedException мы в блоке catch дополнительно завершаем цикл с помощью break, если в условии цикла у нас уже есть проверка на isInterrupted? По-моему что-то одно следует убрать, либо условие из цикла и оставить только while (true), либо break при обработке исключения.

 public class Clock extends Thread < public static void main(String[] args) throws InterruptedException < Clock clock = new Clock(); clock.start(); Thread.sleep(10000); clock.interrupt(); >public void run() < Thread current = Thread.currentThread(); while (!current.isInterrupted()) < try < Thread.sleep(1000); >catch (InterruptedException e) < System.out.println("Работа потока была прервана"); break; >System.out.println("Tik"); > > > 

Интересно, если есть 4 потока, можно ли сделать так, чтобы: — 1-й поток ждал пока не заверлится 3-й; — 2-й поток ждал пока не заверлится 4-й; и все это параллельно. — 3-й потом работал параллельно 4-му; — после завершение 3-го и 4-го потоков 1-й и 2-й потоки работали также параллельно (при условии что 3-й и 4-й потоки завершились одновременно). Как будет выглядеть код? Метод join(); как я понял, регулирует очередность потоков, но не позволяет «создавать несколько параллельных очередностей» или я не прав? Поясните, пожалуйста, знатоки 🙂

Источник

Java Delay – 4 Ways to Add Delay in Java

Let’s discuss about scenario when we want to introduce a delay in execution of a subsequent program. Before we move on further to understand the working of delay in Java, let’s understand some practical scenario in which we would need a delay in execution.

As soon as the application is loaded and the user logged in, we want to fetch the current location of the user. We are aware that calling certain API like Google Maps API would take at least 5-8 seconds of time for fetching a response. In such cases we have to use delay in our code.

Delay in Java

Like any other programming language, Java supports delays. To understand the concept of delay we need to understand about Threads in Java, if you are aware about it you can continue reading otherwise we suggest you learn about threads once before moving ahead. Having knowledge of threads you would be for sure aware about main Thread, the thread in which main function is called. So now if we want to use delay the only possible way is pause the execution of Threads. The Java’s API provides methods for this functionality.

The Most Basic Approach: Thread’s class Sleep() Method

As the name suggests, sleep method is a quick but a dirty approach to execute the delay in Java. This method is present in the Thread class. It simply directs the current thread to sleep for a specific time.

The sleep method accepts the input in milliseconds. So, if you want to pause the execution for 5 seconds, you would need to pass 5000 in the sleep method. In case of sleep method the process is shown as work in progress whereas the operation is set to hold. Now, in such scenario the execution of sleep method might be interrupted if the processor needs to work on some other process of high priority. So, for this purpose Java’s API has implemented sleep method to throw InterruptedException.

Below is the implementation of the sleep method of Thread Class.

So, whenever we are calling the sleep method we would need to either forward the exception or handle the exception using try & catch block like shown in the code below:

Sleep with a Unit Time: Time Unit’s sleep() Method

Another way of doing or calling the sleep method is using TimeUnit’s sleep method. Internally it also uses the Thread’s sleep method but it differs in a way that it accepts Unit Time and the same can be passed in arguments, like shown in below:

For java assignment help you can checkout AssignmentCore whose experts will do Java homework for you.

Just Another Delay Approach: wait() Method

We can use the wait method to pause the execution in a multi-threaded environment and inside a synchronized block. We will keep it for discussion later when we discuss thread. So we use wait when we want a particular thread to wait for the execution till informed.

Like wait(), we have a method notify() and notifyAll(), these methods are called after wait() method. We need to make sure that we call the wait() method only from the synchronized block.

Let’s see using a simple example, in the below example we are calculating the sum of first 100 numbers using threads and printing the sum in different thread.

So, below is our ThreadOne class:

And below is the main class which makes the object of ThreadOne and calculates the sum:

The output of the above code would be something like below:

Value of the ThreadOne’s num is: 0

Value of the ThreadOne’s num is: 10 or something, depending on the value at the time the variable sum is sent to console for printing.

We use the same ThreadOne class:

But modify the ThreadMain class as below:

Waiting For the Thread t1 to complete its execution:

Value of the ThreadOne’s num is: 4950

It happened due to wait() which paused the main() thread till the t1 thread executed it’s method and called the notify() method.

Now all out above solutions are either pausing the execution for a specified amount of time, but what about cases when we are ourselves unsure of the exact wait time. For Ex: we are calling an API whose result might be delayed, in such cases above approach would fail to give proper response. To solve this problem Java gave a great solution in terms of Scheduler.

Last but Least: The ExecutorService based Scheduler

ScheduledExecutorService is an interface provided by Java as a precise solution to the delay problem. ExecutorService is interface provided by Java which can schedule the commands to run after a given delay, it also can schedule a task or command to be executed periodically.

Using the interface user can schedule a piece of code at a specific internal or after a specific delay.

To call the scheduled method we simply need to obtain the object of the scheduler service from the Executor. Let’s see using a simple problem statement to understand the brief working of the executor service.

In the example below we are taking an executor service to create a pool of 6 threads and out of these 6 threads we are submitting 2 tasks. Please note the difference between task and thread here. A callable and runnable are the task which may or may not return something, that we will see when we cover ExecutorService in detail.

Источник