Yield method in java
Вот четыре основных правила «happens-before» в Java: Правило захвата монитора (Monitor Lock Rule): Если поток A захватывает монитор объекта X, а затем выполняет операцию, а поток B должен захватить тот же монитор X, чтобы увидеть результаты изменений, выполненных потоком A. Другими словами, все операции, выполненные потоком A до освобождения монитора X, будут видны потоку B после захвата того же монитора X.
// Поток A synchronized (lock) < sharedVariable = 10; >// Поток B synchronized (lock) < int value = sharedVariable; // Гарантируется, что значение 10 будет видно потоку B > Даже на 64-битных платформах, использование volatile с 64-битными переменными, такими как long и double, может быть недостаточным для обеспечения атомарности сложных операций. Например, если два потока пытаются одновременно выполнить операцию инкремента на volatile long переменной, может возникнуть состояние гонки, потому что инкремент состоит из нескольких операций чтения, модификации и записи. В таких случаях для обеспечения атомарности операций или синхронизации между потоками следует использовать средства синхронизации, такие как synchronized блоки или классы из пакета java.util.concurrent.atomic, которые предоставляют атомарные операции над переменными, включая 64-битные переменные.
volatile в априори не может создавать атомарное представление переменной, он лишь отменяет ее кэширование, что косвенно делает ее атомарной, но volatile != 100% атомарность
Правило 4 «Запись в volatile переменную happens-before чтение из той же переменной» Само собой это не происходит, мы сами это регулируем. Если мы запустим чтение/запись с разных потоков, какой поток и когда прочитает переменную c volatile зависит от самих потоков, и их конкуренции. Сдесь вывод будет разный, но в основном по первому потоку который был запущен.
public class Main < public volatile static String message = "No changes"; public static void main(String[] args) throws InterruptedException < new FreeThread().start(); new MyThread().start(); >public static class MyThread extends Thread < @Override public void run() < message = "Message was changed"; >> public static class FreeThread extends Thread < @Override public void run() < System.out.println(message); >> > public class Solution < public static volatile int proposal = 0; public static void main(String[] args) throws InterruptedException < Thread mt1 = new Mt1(); Thread mt2 = new Mt2(); mt1.start(); mt2.start(); Thread.sleep(100); System.out.println(proposal + " " +Thread.currentThread().getName()); >public static class Mt1 extends Thread < @Override public void run() < proposal = 1; try < Thread.sleep(100); >catch (InterruptedException e) < throw new RuntimeException(e); >System.out.println(proposal + " " +Thread.currentThread().getName()); > > public static class Mt2 extends Thread < @Override public void run() < proposal = 2; try < Thread.sleep(100); >catch (InterruptedException e) < throw new RuntimeException(e); >System.out.println(proposal + " " +Thread.currentThread().getName()); > > А в этом же коде без слипов выводит значения, соответствующие установленным в каждом треде, и никто не ждет никаких записей от других потоков. Выходит, что последний пункт вот вообще не работает с точки зрения синхронизации, потому что результат зависит от скорости выполнения тредов, и в зависимости от нее результаты будут совершенно разными. Это уже не говоря о планировщике. Да, можно починить при помощи join, но в таком случае получается поделка на тему синхронизации и не более. Бред какой-то..
Yield() Method in Java
The yield() method is used in Java to hint the task scheduler to move the currently executing task to the Ready state and move another task or thread to the running state. The task scheduler is free to ignore the hint. Through the yield() method, a thread is willing to yield or relinquish its current use of the processor.
Syntax of Yield() in Java
The general definition of yield function in Java is as follows:
Because the yield() method is a static function, it can be called with its class name as shown below
Here, we call the yield() method on the Thread object. Calling the yield() method on the Thread object pauses the currently executing thread and puts it in Ready state and selects another runnable thread from the ready state to start its execution.
Parameters of Yield() in Java
yield() method doesn’t accept any parameters and is called on the Thread object. The execution of a thread on which yield() is called stops to execute another thread from the ready state.
Return Values of Yield() in Java
The yield() method doesn’t return any value when it is called on the Thread object .
Example
Let us see an example where we will move the currently executing thread back to the ready state from the running state.
Explanation:
- Here, we create two threads, t1 and t2 , that execute the run() method in YieldDemo Class.
- As we can observe from the output, thread t1 start executing first. When the yield() method is invoked, thread t1 goes to the Ready state from the Running state, and thread t2 starts executing.
- Then t2 goes in Ready state because yield() is called on it.
- Now, thread t1 resumes its execution and terminates. The execution of the second thread follows this because it was in a Ready state.
Let us see another example where we are assigning priorities to the threads.
Explanation:
- Here, the priority of thread t1 is 4 , whereas the priority of the second thread t2 is 8 . Because the second thread has the highest priority so thread selector executes it first.
- When the yield() method is called on thread t2 , t2 returns to the Ready state. Now, the selector selects thread t1 for its execution.
- When yield() is called on t1 because t2 has the highest priority, so t2 executes again, and after its execution finishes, thread t1 resumes its execution.
Yield() Method in Java
Let us suppose we have three threads, T1 , T2 and T3 , that need to be executed.
Thread T1 gets the processor and starts executing while the remaining threads T2 and T3 are in the Ready state. The time required for thread T1 is 4 hours, while threads T2 and T3 take only 2 and 4 minutes, respectively. This means threads T1 and T2 need to wait for four hours to complete a total of 6-minute jobs. In such scenarios where one thread takes too long for its completion, we need to have a method that allows the execution of other threads in between if something important is pending. Java has a yield() method to provide such functionality.
When the current executing state receives a job with higher priority than the current executing thread and the current executing thread is willing to yield its use of the processor, the thread scheduler stops current thread and sends it to Ready state and selects different thread with equal or higher priority task to start its execution. The yield() method in the Thread class in Java is called on the current Thread object to send the current running thread back to the ready state.
Use of Yield Method
- It may be useful for debugging or testing purposes, where it may help to reproduce bugs due to race conditions.
- It can be used when creating concurrency control constructs, such as those in the java.util.concurrent.locks package.
Difference between Wait, Sleep, Join and Yield in Java
Let us see a comparison between yield() , join() and sleep() methods.
| Property | yield() | join() | sleep() |
|---|---|---|---|
| Purpose | We use yield() , if a thread is willing to pass its execution (set its status back to Ready state) to give a chance to other remaining threads in the ready state. | We use join() method when a thread is willing to wait until the completion of a different thread. | sleep() method is used if a thread does not want to perform operation for a definite amount of time. |
| Is it overloaded? | No | Yes | Yes |
| Is it final? | No | Yes | No |
| Static method? | Yes | No | Yes |
| Throws exception? | No | Yes | Yes |
Conclusion
- yield() method is defined in Thread.java. It hints to the scheduler that the current thread is ready to yield or relinquish its use of the processor and the scheduler is free to ignore the hint.
- If the thread calls the yield() method, the scheduler checks if there is any thread on the ready state waiting to be executed, it moves the current thread to the Ready state and gives the processor another task.
- yield() method is called on the Thread object and accepts no parameter and does not return any output.
yield — пропуск хода
— Привет, Амиго! У нас сегодня будет небольшой и интересный урок. Я расскажу тебе про yield – статический метод класса Thread.
Элли тебе уже рассказывала, что процессор постоянно переключается между нитями. Каждой нити выделяется небольшой кусочек процессорного времени, называемый квантом. Когда это время истекает – процессор переключается на другую нить и начинает выполнять ее команды. Вызов метода Thread.yield() позволяет досрочно завершить квант времени текущей нити или, другими словами, переключает процессор на следующую нить.
— А зачем нити может понадобиться уступить свое время другой нити?
— Необходимость в этом возникает не часто. Вызов yield приводит к тому, что «наша нить досрочно завершает ход», и что следующая за yield команда начнется с полного кванта времени. Значит шансы, что ее прервут – меньше. Особенно, если она небольшая (по времени). Такой подход можно использовать при оптимизации некоторых процессов.
Еще могу добавить, что метод Thread.sleep(0) работает фактически так же. Думаю, ты вначале будешь использовать метод yield не очень часто, но знать о нем — полезно.
Метод yield() служит причиной того, что поток переходит из состояния работающий (running) в состояние работоспособный (runnable), давая возможность другим потокам активизироваться. Но следующий выбранный для запуска поток может и не быть другим. Метод sleep() вызывает засыпание текущего потока на заданное время, состояние изменяется с работающий (running) на ожидающий (waiting).
Процитирую Виктора: «Если вы знаете, что в текущей итерации run() сделано все необходимое, вы можете подсказать механизму планирования потоков, что процессором теперь может воспользоваться другой поток. Эта подсказка (не более чем рекомендация; нет никакой гарантии, что планировщик потоков «прислушается» к ней) воплощается в форме вызова метода yield(). Вызывая yield(), вы сообщаете системе, что в ней могут выполняться другие потоки того же приоритета» © Философия Java. «В одной нити какой-то команде Х, которую прерывать ну никак нельзя, может понадобиться целый квант времени на свое выполнение, и если до нее была команда Y «поменьше», которая выполнилась, условно говоря, за полкванта, то нашей важной команде X не хватит времени на выполнение, ее прервут, тк началось время другой нити, а это оч нежелательно. В этом случае мы после «маленькой» команды Y пишем yield, чтобы не начинать выполнять X, и когда снова настанет очередь первой нити, команде Х как раз хватит времени на выполнение» © Евгения. Всё получится!
Всё что нужно знать о методе Thread.yield() «Thread.yield() позволяет досрочно завершить квант времени текущей нити» Это не так! Точнее не совсем так. Этот метод только лишь сообщает JVM, что можно и уменьшить процессорное время для выбранной нити.JVM в свою очередь просит об этом планировщик и то в качестве рекомендации. А планировщик очень загадочный молодой человек. Он может: 1)Проигнорировать полностью 2)Вернуть нить обратно в очередь и тут же её вызвать Никаких гарантий, что метод вообще отработает нет. На 7 уровне модуля Java Multithreading сам профессор даёт вот ЭТУ лекцию, в которой говорится, что предсказать что и как планировщик сделает с нашей рекомендацией невозможно, всё зависит от ОС и версии JVM. То есть где то всё таки он работает. И работает так: Предположим планировщик выделил квант времени нашей нити и предположим на середине этого времени увидел yield(). Не дожидаясь окончания этого кванта времени он переключается на другую нить, а нашу нить он отправляет в конец очереди нитей с ТАКИМ ЖЕ приоритетом. Вот и всё) Тем не менее, ветераны труда с JavaRush и хабра утверждают, что метод yield() в реальности применяется примерно НИГДЕ, по крайней мере других мнений мне не довелось встретить сколько бы не искал. В комментах ниже пишут, что лучше выставлять вместо него приоритет нити путём Thread.setPriority(int).Это хоть и применяется редко, но редко это хотя бы не нигде))
Для чего же нужен Thread.yield()? Например, он поможет достичь «состояния гонки» в плохо спроектированной многопоточной системе. Так сказать «отловит баг»
На мой взгляд какое-то не самое лучшее объяснение. Что вообще значит «позволяет досрочно завершить квант времени текущей нити»? Насколько я понял из тех тем, которые я прочитал ничего досрочно не завершается. Используя метод Thread.yield() мы говорим планировщику потоков: «Начальник, нам сейчас процессорное время не очень надо, можешь отдать кому-то другому». А уже планировщик потоков дальше сам решает как действовать, может и проигнорировать наше предложение. Вот что гласит по этому поводу официальная документация: «yield public static void yield() A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint. Yield is a heuristic attempt to improve relative progression between threads that would otherwise over-utilise a CPU. Its use should be combined with detailed profiling and benchmarking to ensure that it actually has the desired effect. It is rarely appropriate to use this method. It may be useful for debugging or testing purposes, where it may help to reproduce bugs due to race conditions. It may also be useful when designing concurrency control constructs such as the ones in the java.util.concurrent.locks package.»