Концессии потока: helive ()
Цель доходности () состоит в том, чтобы сдаться. Это может позволить текущему потоку ввести «Готовное состояние» из «управляемого состояния», чтобы другие потоки ожидания с тем же приоритетом могли получить права на выполнение; Тем не менее, это не может гарантировать, что после текущих вызовов потока hield () другие потоки с тем же приоритетом определенно получат права на выполнение; Также может случиться так, что текущий поток входит в «состояние бега» и продолжает работать!
Пример:
Class Threada Extends Thread {public Threada (String name) {super (name); } public void run () {for (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Когда я разделен на 4, вызов доходности, если (i%4 == 0) Thread.yield (); }}} public class hieldtest {public static void main (string [] args) {threada t1 = new threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); }} (Один раз) Результат работы:
T1 [5]: 0T2 [5]: 0T1 [5]: 1T1 [5]: 2T1 [5]: 3T1 [5]: 4T1 [5]: 5T1 [5]: 6T1 [5]: 7t1 [5]: 8T1 [5]: 9T2 [5]: 1T2 [5]: 2T2 [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5]: 1T2 [5]: 4T2 [5] [5] [5]: 1T2 [5]: 4T2 [5]: 6t2 [5]: 7t2 [5]: 8T2 [5]: 9
Результаты Описание:
Когда «потока T1» может быть целым на 4, он не переключается на «потока T2». Это показывает, что, хотя helive () может позволить потокам входить в «Готовное состояние» из «работающего состояния», он не обязательно позволяет другим потокам получать права на выполнение ЦП (то есть другие потоки входят в «рабочее состояние»), даже если этот «другой поток» имеет тот же приоритет, что и поток в настоящее время вызов доходности ().
Сравнение доходности () и ожидания ():
Мы знаем, что функция wait () состоит в том, чтобы позволить текущему потоку войти в состояние «ожидание (блокировки) из« управляемого состояния », а также выпустить блокировку синхронизации. Функция доходности () - это, что также приведет к тому, что текущий поток оставляет« рабочее состояние ». Их различия: различия::
(1) WAIT () - это позволить потоке войти в «ожидание (блокирующее) состояние» из «управляемого состояния», в то время как не hield () - это позволить потоке войти в «Готовное состояние» из «управляемого состояния».
(2) wait () - это блокировка синхронизации, которая будет отключить объект, который он удерживает, в то время как метод hellive () не выпустит блокировку.
В следующем примере показано, что helipt () не выпустит блокировку:
открытый класс ingdhocktest {частный статический объект obj = new Object (); public static void main (string [] args) {threada t1 = new threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); } static class Threada extends Thread {public Threata (String name) {super (name); } public void run () {// получить синхронизированный (obj) {for (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Когда я разделен на 4, вызов доходности, если (i%4 == 0) Thread.yield (); }}}}}} (Один раз) Результат:
T1 [5]: 0T1 [5]: 1T1 [5]: 2T1 [5]: 3T1 [5]: 4T1 [5]: 5T1 [5]: 6T1 [5]: 7T1 [5]: 8T1 [5]: 9T2 [5]: 0T2 [5]: 1T2 [5]: 2T2 [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5] [5]: 1T2 [5] [5] [5] [5] [5]: 1T2 [5]: 6t2 [5]: 7t2 [5]: 8T2 [5]: 9
Результаты Описание:
Две потоки T1 и T2 запускаются в основной резьбе Main. T1 и T2 будут ссылаться на блокировку синхронизации того же объекта в run (), то есть синхронизированный (OBJ). Во время работы T1, хотя он будет называть Thread.yield (); T2 не получит права на выполнение процессора. Потому что T1 не выпускает «синхронная блокировка, удерживаемая OBJ»!
Нить сон: сон ()
Sleep () определяется в Thread.java.
Функция Sleep () состоит в том, чтобы позволить нынешнему потоку спать, то есть текущий поток будет входить из «состояния бега» в состояние «сон (блокировка)». Sleep () будет указывать время сна, а время сна нить будет больше, чем/равно времени сна; Когда поток снова разбудится, она изменится от «состояния блокировки» на «готовое состояние», ожидая, когда запланирован на ЦП.
Пример:
Class Threada Extends Thread {public Threada (String name) {super (name); } public void run () {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getName (), i); // Когда меня можно разделить на 4, спать на 100 мс, если (i%4 == 0) Thread.sleep (100); }} catch (прерывание Exception e) {e.printStackTrace (); }}} public class sleeptest {public static void main (string [] args) {threada t1 = new threada ("t1"); t1.start (); }} Результаты работы:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9
Результаты Описание:
Программа относительно проста, начала потока T1 в основном потоке. После начала T1, когда расчет I в T1 можно делить на 4, T1 будет спать на 100 миллисекунд через нить. Sleep (100).
Сравнение Sleep () и Wait ():
Мы знаем, что функция wait () состоит в том, чтобы позволить текущему потоку входить в состояние «wat (блокировка) из« состояния работающего », а также освободить блокировку синхронизации. Функция Sleep () состоит в том, чтобы позволить текущему потоку войти в состояние« блокировки) »из« состояния бега ».
Тем не менее, Wait () выпускает блокировку синхронизации объекта, в то время как Sleep () не выпускает блокировку.
В следующем примере показано, что Sleep () не выпустит замок.
открытый класс sleeplocktest {частный статический объект obj = new Object (); public static void main (string [] args) {threada t1 = new threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); } static class Threada extends Thread {public Threata (String name) {super (name); } public void run () {// Получить блокировку синхронизации объекта obJ Synchronized (obj) {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getName (), i); // Когда меня можно разделить на 4, спать на 100 мс, если (i%4 == 0) Thread.sleep (100); }} catch (прерывание Exception e) {e.printStackTrace (); }}}}}}}}} Результаты работы:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9T2: 0T2: 1T2: 2T2: 3T2: 4T2: 5T2: 6T2: 7T2: 8T2: 9
Результаты Описание:
Две потоки T1 и T2 запускаются в основной резьбе Main. T1 и T2 будут ссылаться на блокировку синхронизации того же объекта в run (), то есть синхронизированный (OBJ). Во время работы T1, хотя он будет называть Thread.sleep (100); T2 не получит права на выполнение процессора. Потому что T1 не выпускает «синхронная блокировка, удерживаемая OBJ»!
Обратите внимание, что если мы прокомментируем синхронизированный (OBJ) и снова выполним программу, T1 и T2 могут быть переключены друг на друга. Ниже приведен исходный код после синхронизации Tune Comment (OBJ):
открытый класс sleeplocktest {частный статический объект obj = new Object (); public static void main (string [] args) {threada t1 = new threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); } static class Threada extends Thread {public Threata (String name) {super (name); } public void run () {// Получить блокировку синхронизации объекта obj // synchronized (obj) {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getName (), i); // Когда меня можно разделить на 4, спать на 100 мс, если (i%4 == 0) Thread.sleep (100); }} catch (прерывание Exception e) {e.printStackTrace (); } //}}}}