1. Основные концепции потоков
Понимание потока: поток - это другой путь выполнения в программе
Каждая ветвь называется потоком, а Main () называется основной ветвей, также называемой основной резьбой.
Процесс - это просто статическая концепция, файл .class на машине, файл .exe на машине, это называется процессом. Процесс выполнения программы такой: во -первых, поместите код программы в область кода памяти. После того, как код помещен в область кода, он не начинает выполнять немедленно. Однако это означает, что процесс готов начать. Процесс был сгенерирован, но еще не начал выполнять. Это процесс, поэтому процесс на самом деле является статической концепцией и не может быть перемещен сам по себе. Обычное выполнение процесса относится к основному потоку в процессе, который начинает выполнять, то есть метод Main () начинает выполняться. Процессы - это статическая концепция, и на самом деле потоки работают в наших машинах.
Операционная система Windows поддерживает многопоточное. Он может выполнять много потоков одновременно, а также поддерживает несколько процессов. Таким образом, операционная система Windows-это операционная система, которая поддерживает многопоточную и многопроцесскую. Linux и Uinux также являются операционными системами, которые поддерживают многопоточный и многопроцесс. DOS не поддерживает многопоточную и многопроцесскую. Он поддерживает только отдельные процессы. Только один процесс выполняется в одно и то же время, которое называется однопоточной.
Очень мощный процессор и способен выполнять так много программ одновременно? Нет, выполнение процессора выглядит следующим образом: процессор очень быстрый, и его можно подсчитать сотни миллионов раз через секунду, поэтому ЦП делит свое время на небольшие временные кусочки. Я какое -то время выполняю на этот раз ломтик, в следующий раз, когда Слайс какое -то время выполнит его, и в следующий раз на некоторое время будет выполнять другие. Хотя есть десятки потоков, они могут быть выполнены все из них за очень короткое время. Но для нас, людей, скорость выполнения процессора слишком быстра, поэтому кажется, что он выполняется одновременно, но на самом деле в определенный момент времени на процессоре работает только один поток.
Прежде всего, вам нужно понять три понятия при обучении тем :
1. Процесс: процесс - статическая концепция
2. Поток: в процессе, называемый методом Main (), есть основной поток, который представляет собой программу и другой путь выполнения в процессе.
3. В то же время процессор может поддерживать только один поток для выполнения. Поскольку процессор работает очень быстро, мы выглядим так, как будто мы многомерны.
Что такое настоящее многопоточное? Если на вашей машине есть двойные процессоры или двойные ядра, она действительно многопоточная.
2. Создание и запуск потоков
В Java потоки Java реализованы через класс java.lang.thread, а каждый объект потока представляет новый поток. Есть два способа создания нового потока: первым является наследование от класса потоков, а другой - реализовать интерфейс. Когда виртуальная машина запустится, будет определяться поток, определяемый основным методом (public static void main ()), и этот поток называется основным потоком. Новые потоки могут быть созданы путем создания экземпляров потока. Вам просто нужно новый объект потока, и появится новый поток. Каждый поток завершает свою работу через метод run (), соответствующий конкретному объекту потока. Метод run () называется корпусом резьбы.
Пример 1: Создайте и запустите новый поток, используя реализацию запускаемого интерфейса
Создайте новый поток, чтобы вызвать метод запуска
Пакет cn.galc.test; public class testthread1 {public static void main (string args []) {runner1 r1 = new Runner1 (); // Здесь новый объект класса потока выходит // r1.run (); // Это называется вызовом метода. Выполнение вызова метода состоит в том, чтобы подождать, пока метод run () не будет выполнен до того, как метод main () будет продолжаться. Поток T = новый поток (R1); // Чтобы запустить новый поток, здесь используется новый объект потока // (выполняемая цель) используется здесь. Конструктор T.Start (); // Запуск недавно открытого потока, новый поток выполняет метод run (), а новый поток и основной поток будут выполняться параллельно для (int i = 0; i <10; i ++) {System.out.println ("maintheod:"+i); }}}/*Определите класс для реализации запускаемого интерфейса. Реализация runnable interface означает, что этот класс представляет собой класс потока*/класс Runner1 реализует runnable {public void run () {for (int i = 0; i <10; i ++) {System.out.println ("Runner1:"+i); }}}Процесс выполнения многопоточных программ заключается в следующем:
Вызовите метод запуска непосредственно без открытия нового потока
Результаты работы следующие:
Пример 2: Унаследовать класс потока и переопределить его метод run () для создания и запуска нового потока
пакет cn.galc.test;/*Второй метод создания и запуска потока: определить подкласс потока и реализовать метод run ()*/public class testthread2 {public static void main (String args []) {runner2 r2 = new Runner2 (); r2.start (); // Вызовите метод start (), чтобы запустить недавно открытый поток для (int i = 0; i <= 10; i ++) {System.out.println ("mainmethod:"+i); }}}/*Runner2 класс наследшивает от класса потока, создав объект класса Runner2, вы можете открыть новый поток. Вызовите метод start (), унаследованный от класса потоков. Вы можете запустить недавно открытый поток*/Class Runner2 Extends Thread {public void run () {// Переписать реализацию метода run () для (int i = 0; i <= 10; i ++) {System.out.println ("Runner2:"+i); }}}Выбор использования двух методов для создания новых потоков, а именно реализации запускаемого интерфейса и наследования класса потоков, должен быть приоритет для открытия нового потока. Поскольку реализация интерфейса может реализовать несколько, наследование класса может быть только единственным наследом. Поэтому, когда вы можете использовать запускаемый интерфейс при открытии нового потока, постарайтесь не использовать наследование из класса потока, чтобы открыть новые потоки.
3. Переход состояния потока
3.1. Основные методы управления потоком
3.2. Введение в метод сна/соединения/урожайности
Пример применения метода сна:
пакет cn.galc.test; import java.util.*; public class testthread3 {public static void main (string args []) {mythread thread = new mythread (); Thread.Start (); // Вызовите метод start (), чтобы запустить недавно открытый поток try {/* sthread.sleep(10000); Метод Sleep () - это статический метод, объявленный в классе потока, поэтому вы можете использовать формат Thread.sleep () для вызова * / /*mythread.sleep(10000); Mythread Class наследует класс потоков и, естественно, также наследует метод Sleep (), поэтому вы также можете назвать его, используя формат mythread.sleep () *// *Вызов статических методов может быть непосредственно вызван в форме «name.static method» или «Ссылка на объект. Статическое имя метода» */ mythread.sleep (10000); System.out.println («Основная нить спит в течение 10 секунд и начинается снова»); // При вызове статического метода другого класса в методе Main () вам необходимо использовать метод «класс. Статический метод, где находится статический метод» для вызова /*, поэтому я должен позволить основному потоку спать в течение 10 секунд. Какой поток вызывает метод Sleep (), так что теперь основной поток спит. */} catch (прерывание Exception e) {e.printstackTrace (); } //thread.interrupt() ;//use enterrupt () Метод завершить выполнение потока потока .flag = false; // Изменить условия цикла и завершить мертвый цикл/** * Когда происходит прерывание, непосредственно установите условие цикла на ложь, чтобы выйти из мертвого цикла, * затем прекратите выполнение ребенка. Это лучший способ положить конец детскому потоку* / / *** Метод вызова Enterrupt (), чтобы сломать текущий поток, эквивалентен наличию кастрюли с холодной водой на главную резьбу и разбив выполняющую подпоточность. После того, как выполняется выполнение подпоточной нагрузки, будет выброшено прерывавшее, которое выполнит оператор возврата и завершит выполнение потока. Таким образом, подпоточная резьба заканчивает выполнение потока через 10 секунд выполнения */}} класс Mythread Extends Thread {boolean flag = true; // Определить тег для управления условиями цикла Public void run () {/ * * Примечание. Здесь вы не можете написать исключение, непосредственно за методом пробега (). Бросьте разные исключения, чем переписанный метод. * Итак, вы можете написать только попытку ... catch (), чтобы поймать исключения*/ while (flag) { System.out.println ("================================================================================================================= ===================================================================== ===================================================================== ===================================================================== ===================================================================== ===================================================================== ======================================================================= Конечно, не неправильно назвать его, используя формат «Имя класса. Имя метода»*/ // mythread.sleep (1000); // Использование формата «Имя класса. Имя метода», чтобы вызвать статический метод сон (1000); // Если он прерывается во время сна, прерывание, воспринимается, будет выпущено //, чтобы позволить новой ветке, и затем начнут, а затем начнут, а затем начнут, а затем начнут, а затем начнут вторая тема, а затем начнут, а затем начнут, а затем начнут, а затем начнут, а затем начнут. Каждую секунду в мертвой петле, и текущее системное время распечатывается каждую секунду} Catch (прерывание Exception e) { /** При соле, пластина с холодной водой может прервать сон* Следовательно, когда работающий поток прерывается по некоторым неожиданным причинам, исключение, которое прерывается (прерывание) может быть выброшено* / return;Результаты работы:
Пример метода соединения:
пакет cn.galc.test; public class testthread4 {public static void main (string args []) {mythread2 thread2 = new mythread2 ("mythread"); // При создании нового объекта потока назовите объект потока MyThread Thread2.start (); // Запуск потока Try {thread2.join (); // Вызовите метод join (), чтобы объединить поток, объединить детскую поток Mythread в основной поток // После объединения потока, процесс выполнения программы эквивалентен процессу выполнения (ErrupteDexcection Extrectre -xprace (E.prace stactrectre -xprace {.prace keeptrectre -xprace {.prace keeptrecectre -xprace {e.prace keeptrectrecectrint; } for (int i = 0; i <= 5; i ++) {System.out.println ("Я основной поток"); }}} класс mythread2 extends thread {mythread2 (string s) {super (s); / * * Используйте супер -ключевое слово, чтобы вызвать конструктор родительского класса * Один из конструкторов потока родительского класса: «Публичный поток (название строки)» * Через такой конструктор можно назвать недавно открытым потоком, что облегчает управление потоками */} public void run () {для (int i = 1; i <= 5; i ++) {System.ous.print. getName ()); // Использование // public final String getName (), определенная в потоке родительского класса, возвращает имя этого потока. try {sleep (1000); // заставить дочернюю нить спать на 1 секунду каждый раз, когда он выполняется} catch (прерывание Exception e) {return; }}}}Результаты работы:
Пример использования метода урожайности:
пакет cn.galc.test; public class testthread5 {public static void main (string args []) {mythread3 t1 = new mythread3 ("t1"); /* Две дочерние нити T1 и T2 были открыты одновременно. T1 и T2 оба выполняют метод run ()*//*В общей сложности 3 потока параллельно во время выполнения этой программы, а именно дочерних потоков T1 и T2 и основного потока*/ mythread3 T2 = new Mythread3 ("T2"); t1.start (); // стартовая детская нить t1 t2.start (); // стартовое детское поток T2 для (int i = 0; i <= 5; i ++) {System.out.println («Я основной поток»); }}} класс mythread3 extends thread {mythread3 (String s) {super (s); } public void run () {for (int i = 1; i <= 5; i ++) {System.out.println (getName () + ":" + i); if (i%2 == 0) {helld (); // Когда выполнение достигает, я может быть разделен на 2, выпускается текущее выполнение потока и позволить другому потоку, выполняющему метод run (), сначала/ * * * Вы можете увидеть во время работы программы, * Когда поток T1 выполнен (i%2 == 0), он может дать 2 -й тема 2 -го, и когда я выполняет (i%2 == 0). Времена, он будет отдавать поток потоке T1 к приоритетному выполнению */}}}Результаты работы следующие:
Выше всего содержание этой статьи. Мы надеемся, что это может вам помочь.