Эта статья представляет собой краткое изложение основного использования многопоточного чтения Java.
Эта статья объяснит основное использование многопоточного чтения Java из следующих аспектов:
Как использовать многопоточный
Два способа запустить ветку
Java предоставляет два способа использования многопоточного. Один из них - написать класс для наследственного потока, затем перезаписать метод запуска, а затем вызовать метод запуска, чтобы запустить поток. В настоящее время этот класс запустит код в методе запуска так, как другой поток. Другой способ - написать класс для реализации запускаемого интерфейса, затем реализовать запуск метода интерфейса, а затем создать объект потока, использовать класс, который реализует запускаемый интерфейс в качестве параметра конструкции, передайте его в объект потока и, наконец, объект потока вызывает метод запуска.
Метод запуска здесь - это метод с функцией запуска, который внутренне вызывает метод запуска. Следовательно, только при запуске метода запуска будет запущен другой поток, метод запуска будет вызван непосредственно или запускается в одном и том же потоке, а не работает в другом потоке
Кроме того, метод запуска просто говорит виртуальной машине, что поток может быть запущен, что означает, что поток находится в состоянии готового состояния, но это не означает, что вызов запуска будет работать немедленно. Это требует ожидания JVM, чтобы решить, когда выполнить поток. Другими словами, если есть два потока A и B, сначала запускаются вызовы, а вызовы B начинаются позже, это не означает, что поток A выполняется сначала, а поток B работает позже. Все это определяется JVM и может считаться случайным запуск.
Ниже мы используем фактический код, чтобы проиллюстрировать два способа запуска потоков:
Первый тип наследует нить
Общедоступный класс ExampleTread Extends Thread {@Override public void run () {super.run (); System.out.println («Это пример, унаследованная от потока»); }}Тестовый код может быть найден в классе ExampleThreadTest в тестовом каталоге
Другой способ реализует запускаемый интерфейс
Общедоступный класс Ex.preverunable реализует {public void run () {System.out.println («Это класс, который реализует беглый интерфейс»); }}Для тестового кода вы можете увидеть класс ExemberRunabletest в тестовом каталоге.
Как получить информацию о многопользовании
После начала многопоточного чтения мы надеемся получить некоторую информацию о запущенном потоке через некоторые API. JDK предоставляет нам метод класса потоков, чтобы получить некоторую информацию о потоке.
Получите имя ветки
Эти методы являются внутренними методами потока, поэтому мы можем назвать эти методы двумя способами. Одним из них является то, что когда наш класс наследует поток для использования многопоточного, мы можем использовать это, чтобы назвать его. Другим способом является вызвать эти методы через Thread.currentThread (). Однако эти два метода различаются в разных сценариях использования.
Давайте кратко рассмотрим использование двух методов.
Первый Thread.currentThread () используется, код заключается в следующем:
Общедоступный класс exampleCurrentThread Extends {public exampleCurrentThread () {System.out.println ("Печать метода конструктора:" + thread.currentThread (). getName ()); } @Override public void run () {super.run (); System.out.println ("Печать метода запуска:" + thread.currentthread (). GetName ()); }}Тестовый код заключается в следующем:
Общедоступный класс exampleCurrentThreadTest Extends testcase {public void testinit () Throws exection {exampleCurrentThread Thread = new SexampleCurrentThread (); } public void testrun () Throws Exception {exampleCurrentThread Thread = new CamempreCurrentThread (); Thread.Start (); Thread.sleep (1000); }}Результаты следующие:
Печать метода конструктора: печать метода MainRun: печать метода строительства потока-0: Main
Почему мы используем Thread.currentThread () Inside ExmarleCurrentThread, чтобы показать, что метод конструкции печатается как основной, потому что Thread.CurrentThread () возвращает информацию, которую сегмент кода вызывается этим потоком. Очевидно, что метод строительства выполняется основным потоком, а метод выполнения выполняется потоком, который мы начали сами. Поскольку он не назван, это по умолчанию Thread-0.
Затем мы смотрим на наследство от потока и называем это с этим.
Public Class ComplexCurrentThread Extends Thread {public ComplexCurrentThread () {System.out.println ("begin ====================="); System.out.println ("thread.currentThread (). GetName =" + thread.currentThread (). GetName ()); System.out.println ("this.getName () =" + this.getName ()); System.out.println ("end =================================================================================================== System.out.println ("Thread.currentThread (). GetName =" + think.currentThread (). GetName ();Тестовый код заключается в следующем:
Public Class ComplexCurrentThreadTest Extends TestCase {public void TestRun () Throws Exception {ComplexCurrentThread Thread = new ComplexCurrentThread (); Thread.SetName ("byHieg"); Thread.Start (); Thread.sleep (3000); }}Результаты следующие:
begin ============ CurrentThread (). getName = mainThis.getName () = Thread-0end ===========================================
Прежде всего, при создании объекта конструктор все еще выполняется основным потоком, поэтому Thread.currentThread () получает имя основного потока, но этот метод относится к объекту, который вызывает метод, то есть информация потока ComplexCurrentThread. Там пока нет SetName, так что это имя по умолчанию. Тогда метод запуска либо Thread.currentThread (), либо возвращает информацию потока с помощью набора имен BYHIEG.
Таким образом, Think.currentThread относится к информации потока, которая специально выполняет этот блок кода. Конструктор выполняется Main, а метод выполнения - какой поток запускается, а какой поток выполняет запуск. С этой точки зрения, информация, которую это может получить, является неточной, потому что, если мы выполним это. GetName () в запуске, но метод запуска запускается другим потоком, мы не можем получить информацию о новом городе, запускающем метод запуска через это. GetName. И только классы, которые наследуют поток, могут иметь такие методы, как GetName, что является катастрофой для языков функций Java, которые не имеют многочисленных наследия. Для всей информации о потоках, которые мы хотим получить после этого, мы используем Thread.currentThread () для вызова API.
Получите идентификатор потока
Позвоните GetId, чтобы получить уникальную идентификацию потока. Это то же самое, что и использование GetName выше. Нечего сказать. Вы можете напрямую взглянуть на пример wardThread и его тестового класса.
Определить, выживает ли поток
Функция метода isalive () состоит в том, чтобы проверить, активен ли поток. Так называемое активное состояние означает, что поток был запущен, но не прекращается. То есть после того, как нить начинается, он считается живым.
Давайте посмотрим на конкретные примеры:
открытый класс AliveThread Extends Thread {@Override public void run () {super.run (); System.out.println («Это жив в методе прогона» + "" + thread.currentThread (). Isalive ()); }}Метод испытаний заключается в следующем:
открытый класс AliveThreadTest Extends testcase {public void testrun () Throws Exception {aliveThread Thread = new AliveThread (); System.out.println ("begin ==" + thread.isalive ()); Thread.Start (); Thread.sleep (1000); System.out.println ("end ==" + think.isalive ()); Thread.sleep (3000); }}Результаты следующие:
Начните == Истинность ли в ложном методе == false
Мы можем обнаружить, что до начала поток считается невозможным, а затем, когда он работает, он жив. Когда метод выполнения выполняется, он считается невозможным.
Как остановить ветку
Определите, прекратилась ли поток
JDK предоставляет некоторые методы, чтобы определить, прекращается ли поток - isErenprupted () и прерван ()
Как остановить потоки
Это более важный метод получения информации о потоке, поскольку он связан с методом завершения потоков. Позвольте мне сначала поговорить о нескольких способах прекращения нитей:
Я не буду говорить о первом, метод второй остановки () был заброшен, потому что могут возникнуть следующие причины:
Для конкретных примеров вы можете увидеть Stoplockthread и его тестовый класс Stoplockthreadtest
Третий тип - это рекомендуемый в настоящее время метод завершения, вызывая прерывание, а затем определение того, прекратить ли расторжение в методе прогона. Есть два способа судить о прекращении. Один из них - это статический метод прерванного () класса потока, а другой - метод элемента потока isErengrepted (). Существует разница между этими двумя методами. Первый метод автоматически сбросит состояние. Если прерывание () называется дважды подряд, если он является ложным в первый раз, во второй раз это должно быть правдой. И Isretrupted () не будет.
Примеры следующие:
public class exampleTruptThread Extends Thread {@Override public void run () {super.run (); try {for (int i = 0; i <50000000; i ++) {if (прерывание ()) {system.out.println («Это уже состояние остановки, я хочу выйти»); бросить новое прерывание («Стоп ......»); } System.out.println ("i =" + (i + 1)); }} catch (прерывание Exception e) {System.out.println ("stop willy"); }}}Тестовый код заключается в следующем:
public class exampletruptThreadTest Extends testcase {public void testrun () Throws Exception {examentInterTruptThread Thread = new Example InternateRUptThread (); Thread.Start (); Thread.sleep (1000); Thread.interrupt (); }}Четвертый метод такой же, как и третий. Единственное отличие состоит в том, чтобы заменить исключение брошенного в приведенном выше коде на возврат. Я все еще люблю делать исключения. Здесь есть много форм обработки, таких как печать информации, закрытие или захват ресурса, а затем снова бросить ее в верхний слой.
Обратите внимание, что исключением, которое мы бросили выше, является прерыванием. Здесь мы кратко говорим о причинах, по которым это исключение может быть получено. В случае исходного сном потока, вызовите прерывание, чтобы завершить поток, или сначала завершить поток, а затем позвольте потоку спать.
Как приостановить поток
В JDK представлены следующие два метода для приостановки потоков и восстановления потоков.
Эти два метода являются заброшенными методами, такими как метод остановки, и их использование совпадает с остановкой, жестоко подвешивающими потоками и восстановлением потоков. Основные причины, по которым эти два метода заброшены:
Некоторые другие использование потоков
Некоторые другие основные использование потоков следующие:
Концессии нить
JDK предоставляет метод доходности () для того, чтобы поток отказался от текущего ресурса ЦП и предоставить его другим задачам, чтобы занять время процессора, но это также случайная вещь. Возможно, это займет время сразу после отказа от ресурсов.
Для конкретных примеров, пожалуйста, см. Exampleyieldthread и его тестовый класс Exampleyieldthreadtest
Установить приоритет потоков
Мы можем установить приоритет потоков, чтобы позволить ЦП как можно больше, чтобы отправить ресурсы выполнения в потоки с более высоким приоритетом. Java устанавливает 1-10 10 приоритетных уровней, и существует три статических переменных, чтобы обеспечить три приоритетных уровня:
/*** Минимальный приоритет, который может иметь поток. */ public final Static int min_priority = 1; /*** Приоритет по умолчанию, который назначен потоку. */ public final Static int norm_priority = 5; /*** Максимальный приоритет, который может иметь поток. */ public final Static int max_priority = 10;
Мы можем установить приоритет потока посредством SetPriority, и можем напрямую передать три статических переменных для апелляции или напрямую пройти в номерах 1-10. После настройки поток будет иметь разные приоритеты. Что произойдет, если мы не установим приоритет?
Приоритет потоков наследуется. Если мы запустим тему B в потоке A, AB имеет такой же приоритет. Как правило, когда мы запускаем поток в основном потоке, мы имеем последовательный приоритет с основным потоком. Приоритет основного потока - 5 по умолчанию.
Вот несколько правил для приоритета:
Нить охрана
JDK предоставляет метод SetDaemon для установки потока, чтобы стать потоком демона. Характеристика потоков демона заключается в том, что после выполнения других нитей, не являющихся данными, потоки демона будут автоматически уничтожены. Типичным примером является recycler GC.
Для получения подробной информации вы можете увидеть exampledaemonthread и exampledeamonthreadtest.
Суммировать
В этой статье в основном суммируются некоторые основные использование потоков Java и включены во вторую статью о безопасности потоков и синхронизации.
Выше всего содержание этой статьи. Я надеюсь, что содержание этой статьи поможет всем, кто учится или работа. Я также надеюсь поддержать Wulin.com больше!