Недавно я изучил и изучал использование многопоточного многопоточного чтения Java, а затем суммировал его после прочтения понимания новичков.
1. Унаследовать класс потоков для реализации многопоточного
Хотя метод, который наследует класс потоков, указан как метод реализации с несколькими потоками, поток по существу является экземпляром запускаемого интерфейса, который представляет экземпляр потока, и единственный способ запуска потока-это метод экземпляра start () экземпляра поток. Метод start () - это собственный метод, который запустит новый поток и выполнит метод run (). Этот метод очень прост в реализации многопоточного. Непосредственно расширяя поток через свой собственный класс и переписывая метод run (), вы можете запустить новый поток и выполнить метод run (), который вы определяете. Например:
открытый класс Mythread Extends Thread {public void run () {System.out.println ("mythread.run ()"); }} Запустите поток в нужном месте следующим образом:
Mythread mythread1 = new mythread (); Mythread mythread2 = new mythread (); mythread1.start (); mythread2.start ();
2. Реализуйте запускаемый интерфейс для реализации многопоточного
Если ваш класс уже расширяет другой класс, вы не можете напрямую расширить поток. В настоящее время вы должны реализовать запускаемый интерфейс следующим образом:
открытый класс MyThread расширяет другие Class Reflaments Runnable {public void run () {System.out.println ("mythread.run ()"); }} Чтобы запустить Mythread, вам нужно сначала создать экземпляр и передать свой собственный экземпляр Mythread:
Mythread mythread = new mythread (); Thread Think = новый поток (Mythread); Thread.Start ();
Фактически, когда запускаемый целевой параметр передается потоку, метод потока run () будет вызывать target.run (), см. В исходном коде JDK:
public void run () {if (target! = null) {target.run (); }} 3. Используйте исполнители, Callible и Future для достижения многопоточного с результатом возврата результатов
Executorservice, Callible и Future Objects на самом деле являются функциональными классами в рамках исполнителя. Это очень подробное объяснение структуры. Поток, который возвращает результат, является новой функцией, представленной в JDK1.5. Это действительно очень практично. С помощью этой функции мне не нужно переживать много проблем, чтобы получить возвратную ценность, и даже если она реализована, она может быть полна лазейков.
Задачи, которые могут возвращать значения, должны реализовать разбираемый интерфейс, и аналогично, задачи, которые не возвращают значения, должны иметь выполняемый интерфейс. После выполнения вызова задачи вы можете получить будущий объект. Вызовите Get on the Object, чтобы получить объект, возвращаемый по вынуждению задачи. В сочетании с ExecutorService интерфейса пула потоков вы можете реализовать легендарный многопоточный результат с результатом возврата. Ниже приведен полный многопоточный тестовый пример с возвращенными результатами. Если вы подтвердили его в соответствии с JDK1.5, вы можете использовать его напрямую. Код заключается в следующем:
импортировать java.util.concurrent.*; импортировать java.util.date; импортировать java.util.list; импортировать java.util.arraylist; / *** Поток с возвращаемым значением*/ @suppresswarnings ("uncecked") открытый тест класса {public static void main (string [] args) бросает выполнение ExectionExcept System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Create a thread pool ExecutorService pool = Executors.newfixedthreadpool (tasksize); System.out.println (">>>" + f.get (). ToString ()); // Получить выполняемые результаты всех параллельных задач для (будущее F: List) {// Получить возвращаемое значение задачи из будущего объекта и вывести его в консольную систему.out.println (">>>" + f.get (). ToString ()); } Date Date2 = новая дата (); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MyCallable (String Tasknum) {this.tasknum = tasknum; System.out.println (">>>" + Tasknum + "Завершение задачи"); Описание кода:
В приведенном выше коде класс исполнителей предоставляет серию заводских методов для создания пула потоков, а возвращаемые пулы потоков все реализуют интерфейс Executorservice.
Public Static Executorsers NewFixedThreadPool (int nthreads)
Создает пул потоков с фиксированным количеством потоков.
Public Static ExecutorService newcachedThreadpool ()
Создайте кэш -пул потоков, вызов Execute повторно использует ранее сконструированные потоки (если поток доступен). Если существующий поток недоступен, создайте новый поток и добавьте его в бассейн. Прекратите и удалите потоки из кэша, которые не использовались в течение 60 секунд.
Public Static ExecutorService NewsingLethreadExeCutor ()
Создайте однопоточного исполнителя.
Public Static SeduledExeCutorService NewschedDThreadPool (int corePoolsize)
Создайте пул потоков, который поддерживает временные и периодические выполнения задач, который может использоваться в большинстве случаев вместо класса таймера.
Exectoreservice предоставляет метод отправки (), передавая вызов или запускающегося и возвращающего будущее. Если пул фоновых потоков исполнителя не завершил вызов, этот вызов возвращает метод get () будущего объекта, который будет блокироваться до тех пор, пока расчет не будет завершен.