Any application can have multiple processes (instances). Each of this process can be assigned either as a single thread or multiple threads.

We will see in this tutorial how to perform multiple tasks at the same time and also learn more about threads and synchronization between threads.

In this tutorial, we will learn-

What is Single Thread?

A single thread is basically a lightweight and the smallest unit of processing. Java uses threads by using a "Thread Class".

There are two types of thread – user thread and daemon thread (daemon threads are used when we want to clean the application and are used in the background).

When an application first begins, user thread is created. Post that, we can create many user threads and daemon threads.

Single Thread Example:

Package demotest; public class GuruThread { public static void main(String args) { System.out.println("Single Thread"); } }

Advantages of single thread:

  • Reduces overhead in the application as single thread execute in the system
  • Also, it reduces the maintenance cost of the application.

What is Multithreading?

Multithreading in java is a process of executing two or more threads simultaneously to maximum utilization of CPU.

Multithreaded applications are where two or more threads run concurrently; hence it is also known as Concurrency in Java. This multitasking is done, when multiple processes share common resources like CPU, memory, etc.

Each thread runs parallel to each other. Threads don"t allocate separate memory area; hence it saves memory. Also, context switching between threads takes less time.

Example of Multi thread:

Package demotest; public class GuruThread1 implements Runnable { public static void main(String args) { Thread guruThread1 = new Thread("Guru1"); Thread guruThread2 = new Thread("Guru2"); guruThread1.start(); guruThread2.start(); System.out.println("Thread names are following:"); System.out.println(guruThread1.getName()); System.out.println(guruThread2.getName()); } @Override public void run() { } }

Advantages of multithread:

  • The users are not blocked because threads are independent, and we can perform multiple operations at times
  • As such the threads are independent, the other threads won"t get affected if one thread meets an exception.

Thread Life Cycle in Java

The Lifecycle of a thread:

There are various stages of life cycle of thread as shown in above diagram:

  1. Runnable
  2. Running
  3. Waiting
  1. New: In this phase, the thread is created using class "Thread class".It remains in this state till the program starts the thread. It is also known as born thread.
  2. Runnable: In this page, the instance of the thread is invoked with a start method. The thread control is given to scheduler to finish the execution. It depends on the scheduler, whether to run the thread.
  3. Running: When the thread starts executing, then the state is changed to "running" state. The scheduler selects one thread from the thread pool, and it starts executing in the application.
  4. Waiting: This is the state when a thread has to wait. As there multiple threads are running in the application, there is a need for synchronization between threads. Hence, one thread has to wait, till the other thread gets executed. Therefore, this state is referred as waiting state.
  5. Dead: This is the state when the thread is terminated. The thread is in running state and as soon as it completed processing it is in "dead state".

Some of the commonly used methods for threads are:

Method Description
start() This method starts the execution of the thread and JVM calls the run() method on the thread.
Sleep(int milliseconds) This method makes the thread sleep hence the thread"s execution will pause for milliseconds provided and after that, again the thread starts executing. This help in synchronization of the threads.
getName() It returns the name of the thread.
setPriority(int newpriority) It changes the priority of the thread.
yield () It causes current thread on halt and other threads to execute.

Example: In this example we are going to create a thread and explore built-in methods available for threads.

Package demotest; public class thread_example1 implements Runnable { @Override public void run() { } public static void main(String args) { Thread guruthread1 = new Thread(); guruthread1.start(); try { guruthread1.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } guruthread1.setPriority(1); int gurupriority = guruthread1.getPriority(); System.out.println(gurupriority); System.out.println("Thread Running"); } }

Explanation of the code:

Code Line 2: We are creating a class "thread_Example1" which is implementing the Runnable interface (it should be implemented by any class whose instances are intended to be executed by the thread.)

Code Line 4: It overrides run method of the runnable interface as it is mandatory to override that method

Code Line 6: Here we have defined the main method in which we will start the execution of the thread.

Code Line 7: Here we are creating a new thread name as "guruthread1" by instantiating a new class of thread.

Code Line 8: we will use "start" method of the thread using "guruthread1" instance. Here the thread will start executing.

Code Line 10: Here we are using the "sleep" method of the thread using "guruthread1" instance. Hence, the thread will sleep for 1000 milliseconds.

Code 9-14: Here we have put sleep method in try catch block as there is checked exception which occurs i.e. Interrupted exception.

Code Line 15: Here we are setting the priority of the thread to 1 from whichever priority it was

Code Line 16: Here we are getting the priority of the thread using getPriority()

Code Line 17: Here we are printing the value fetched from getPriority

Code Line 18: Here we are writing a text that thread is running.

5 is the Thread priority, and Thread Running is the text which is the output of our code.

Java Thread Synchronization

In multithreading, there is the asynchronous behavior of the programs. If one thread is writing some data and another thread which is reading data at the same time, might create inconsistency in the application.

When there is a need to access the shared resources by two or more threads, then synchronization approach is utilized.

Java has provided synchronized methods to implement synchronized behavior.

In this approach, once the thread reaches inside the synchronized block, then no other thread can call that method on the same object. All threads have to wait till that thread finishes the synchronized block and comes out of that.

In this way, the synchronization helps in a multithreaded application. One thread has to wait till other thread finishes its execution only then the other threads are allowed for execution.

It can be written in the following form:

Synchronized(object) { //Block of statements to be synchronized }

Java Multithreading Example

In this example, we will take two threads and fetch the names of the thread.

Example1:

GuruThread1.java package demotest; public class GuruThread1 implements Runnable{ /** * @param args */ public static void main(String args) { Thread guruThread1 = new Thread("Guru1"); Thread guruThread2 = new Thread("Guru2"); guruThread1.start(); guruThread2.start(); System.out.println("Thread names are following:"); System.out.println(guruThread1.getName()); System.out.println(guruThread2.getName()); } @Override public void run() { } }

Explanation of the code:

Code Line 3: We have taken a class "GuruThread1" which implements Runnable (it should be implemented by any class whose instances are intended to be executed by the thread.)

Code Line 8: This is the main method of the class

Code Line 9: Here we are instantiating the Thread class and creating an instance named as "guruThread1" and creating a thread.

Code Line 10: Here we are instantiating the Thread class and creating an instance named a "guruThread2" and creating a thread.

Code Line 11: We are starting the thread i.e. guruThread1.

Code Line 12: We are starting the thread i.e. guruThread2.

Code Line 13: Outputting the text as "Thread names are following:"

Code Line 14: Getting the name of thread 1 using method getName() of the thread class.

Code Line 15: Getting the name of thread 2 using method getName() of the thread class.

When you execute the above code, you get the following output:

Thread names are being outputted here as

  • Guru1
  • Guru2

Example 2:

In this example, we will learn about overriding methods run() and start() method of a runnable interface and create two threads of that class and run them accordingly.

Also, we are taking two classes,

  • One which will implement the runnable interface and
  • Another one which will have the main method and execute accordingly.
package demotest; public class GuruThread2 { public static void main(String args) { // TODO Auto-generated method stub GuruThread3 threadguru1 = new GuruThread3("guru1"); threadguru1.start(); GuruThread3 threadguru2 = new GuruThread3("guru2"); threadguru2.start(); } } class GuruThread3 implements Runnable { Thread guruthread; private String guruname; GuruThread3(String name) { guruname = name; } @Override public void run() { System.out.println("Thread running" + guruname); for (int i = 0; i < 4; i++) { System.out.println(i); System.out.println(guruname); try { Thread.sleep(1000); } catch (InterruptedException e) { System.out.println("Thread has been interrupted"); } } } public void start() { System.out.println("Thread started"); if (guruthread == null) { guruthread = new Thread(this, guruname); guruthread.start(); } } }

Explanation of the code:

Code Line 2: Here we are taking a class "GuruThread2" which will have the main method in it.

Code Line 4: Here we are taking a main method of the class.

Code Line 6-7: Here we are creating an instance of class GuruThread3 (which is created in below lines of the code) as "threadguru1" and we are starting the thread.

Code Line 8-9: Here we are creating another instance of class GuruThread3 (which is created in below lines of the code) as "threadguru2" and we are starting the thread.

Code Line 11: Here we are creating a class "GuruThread3" which is implementing the runnable interface (it should be implemented by any class whose instances are intended to be executed by the thread.)

Code Line 13-14: we are taking two class variables from which one is of the type thread class and other of the string class.

Code Line 15-18: we are overriding the GuruThread3 constructor, which takes one argument as string type (which is threads name) that gets assigned to class variable guruname and hence the name of the thread is stored.

Code Line 20: Here we are overriding the run() method of the runnable interface.

Code Line 21: We are outputting the thread name using println statement.

Code Line 22-31: Here we are using a for loop with counter initialized to 0, and it should not be less than 4 (we can take any number hence here loop will run 4 times) and incrementing the counter. We are printing the thread name and also making the thread sleep for 1000 milliseconds within a try-catch block as sleep method raised checked exception.

Code Line 33: Here we are overriding start method of the runnable interface.

Code Line 35: We are outputting the text "Thread started".

Code Line 36-40: Here we are taking an if condition to check whether class variable guruthread has value in it or no. If its null then we are creating an instance using thread class which takes the name as a parameter (value for which was assigned in the constructor). After which the thread is started using start() method.

When you execute the above code you get the following output:

There are two threads hence, we get two times message "Thread started".

We get the names of the thread as we have outputted them.

It goes into for loop where we are printing the counter and thread name and counter starts with 0.

The loop executes three times and in between the thread is slept for 1000 milliseconds.

Hence, first, we get guru1 then guru2 then again guru2 because the thread sleeps here for 1000 milliseconds and then next guru1 and again guru1, thread sleeps for 1000 milliseconds, so we get guru2 and then guru1.

Summary :

In this tutorial, we saw multithreaded applications in Java and how to use single and multi threads.

  • In multithreading, users are not blocked as threads are independent and can perform multiple operations at time
  • Various stages of life cycle of the thread are,
    • Runnable
    • Running
    • Waiting
  • We also learned about synchronization between threads, which help the application to run smoothly.
  • Multithreading makes many more application tasks easier.

Java — это высокоуровневый язык программирования, разработанный Sun Microsystems. Первоначально создавался для разработки программ для телеприставок и карманных устройств, но позже стал популярным и востребованным языком для создания веб-приложений. Oracle приобрела Sun Microsystems в январе 2010 года, поэтому Java теперь поддерживается и распространяется Oracle.

Java применяет модель объектно-ориентированного программирования и может использоваться для создания приложений, которые могут запускаться на одном компьютере или распределяться между серверами и клиентами в сети. Его также можно использовать для создания небольшого модуля приложения или апплета для использования в качестве части веб-страницы.

Преимущества

Синтаксис Java похож на C ++, но является строго объектно-ориентированным языком программирования. Например, большинство программ Java содержат классы, которые используются для определения объектов и методов. Методы, в свою очередь, назначаются отдельным классам. Java также известен как более строгая формальная знаковая система, чем C ++. Это означает, что переменные и функции должны быть явно определены, что исходный код может выявлять ошибки или «исключения» легче и быстрее, чем другие языки. Это также ограничивает другие типы ошибок, которые могут быть вызваны неопределенными переменными или неназначенными типами.

В отличие от исполняемых файлов Windows (.EXE-файлов) или приложений Macintosh (файлы.APP), программы Java не запускаются непосредственно операционной системой. Вместо этого данные интерпретируются виртуальной машиной Java или JVM, которая работает на нескольких платформах. Все Java-программы являются мультиплатформенными и могут работать на разных платформах, включая компьютеры Macintosh, Windows и Unix. JVM должен быть установлен для приложений или апплетов для запуска. Доступен в виде бесплатной загрузки.

Элементы и принципы

Успеху и популярности Java способствовали характеристики языка. Перечислим основные из них:

    Программы, созданные на Java, обладают качеством переносимости в сети. Исходный код скомпилирован так, что язык программирования вызывает байт-код, который можно запускать в любом месте сети на сервере или клиенте с виртуальной машиной Java (JVM). JVM интерпретирует байт-код в коде, который будет работать на компьютерном оборудовании. Напротив, большинство языков программирования, таких как COBOL, C ++, Visual Basic или Smalltalk, компилируют код в двоичный файл. Бинарные файлы зависят от платформы, поэтому программа, написанная для компьютера под управлением Windows на базе Intel, не может запускать Mac, Linux-машину или мэйнфрейм IBM. JVM включает в себя необязательный компилятор Just-in-time (JIT), который динамически компилирует байт-код в исполняемый код в качестве альтернативы интерпретации одной инструкции байт-кода за раз. Во многих случаях динамическая компиляция JIT быстрее, чем интерпретация виртуальной машины.

    Надежность кода. В отличие от программ, написанных на C ++ и некоторых других языках, объекты Java не содержат ссылок на внешние данные или другие известные объекты. Это гарантирует, что инструкция не содержит адрес хранения данных в другом приложении или в самой операционной системе, из-за чего программа и сама операционная система могут завершиться или инициировать сбой в работе. JVM выполняет ряд проверок на каждом объекте для обеспечения целостности.

    Java — объектно-ориентированный язык. Объект может воспользоваться тем, что он является частью класса объектов и наследует код, который является общим для класса. Данный метод можно рассматривать как одну из возможностей или поведения объекта. Объектно-ориентированный метод относительно распространен в современном ландшафте программирования, но еще в 1996 году лишь несколько языков эффективно применяли объектно-ориентированные концепции и шаблоны проектирования.

    Гибкость апплетов. Java-апплет имеет все характеристики, предназначенные для быстрого запуска.

    Java прост для изучения. Синтаксис языка аналогичен C ++. Если разработчик владеет языкам С/С++, освоить данный язык не составит труда.

    Распространенным заблуждением является то, что существует связь между Java и JavaScript. Эти языки имеют сходство в синтаксисе, но с конструктивной точки зрения являются разными структурами.

Платформы

Существуют три ключевые платформы, на которых программисты разрабатывают Java-приложения:

    Java SE — простые автономные приложения разрабатываются с использованием Java Standard Edition. Ранее известный как J2SE, Java SE предоставляет все API, необходимые для разработки традиционных настольных приложений.

    Java EE — Java Enterprise Edition, ранее известная как J2EE, обеспечивает возможность создания серверных компонентов, которые могут отвечать на веб-цикл запроса-ответа. Такая компоновка позволяет создавать Java-программы, которые могут взаимодействовать с интернет-клиентами, включая веб-браузеры, клиенты на базе CORBA и даже веб-сервисы на основе REST и SOAP.

    Java ME — Java также предоставляет легкую платформу для известную как Java Micro Edition, ранее известная как J2ME. Java ME зарекомендовала себя очень популярной платформой для разработки встроенных устройств, но она изо всех сил пыталась добиться успеха на арене разработки смартфонов. С точки зрения развития смартфонов, Android стал платформой мобильной разработки.

Примеры использования

Используя различные компоненты, предоставляемые Java EE, разработчикам легко писать программы, в которых используются популярные шаблоны проектирования программного обеспечения и универсально согласованные передовые методы.

Фреймворки Struts, Spring и JavaServer Faces используют сервлет Java для реализации шаблона проектирования переднего контроллера для централизации запросов.

Между тем большая часть экосистемы Java — это огромное количество проектов с открытым исходным кодом, программных платформ и API, которые создало сообщество с использованием языка. Например, в Apache Foundation размещаются различные проекты, написанные с использованием Java, в том числе:

    Простые рамки ведения журналов для Java (SLF4J).

    Большие платформы обработки данных.

    Интеграционные платформы, такие как Apache Camel, Apache Axis и CXF для разработки веб-сервисов RESTful.

    Платформы разработки микросервисов.

Другие предприятия попытаются перевести среды Java EE в облако. Поскольку разработчики создают облачные сервисы, возможность быстрого масштабирования этих сервисов является ключевой проблемой, равно как и возможность совместной работы в облаке.

Критика

Синтаксис Java часто осуждается за многословность. Избыточные сеттеры и геттеры, сильная типизация, делают Java-программы раздутыми. В качестве ответа появилось несколько периферийных языков для решения этой проблем, в том числе Groovy, которые быстро стали приобретать популярность.

Другой недостаток заключается в том, что Java-программы не могут линейно масштабироваться в мире высокопроизводительных вычислений. Из-за того что Java ссылается на объекты внутри, сложные и параллельные операции на основе списка могут привести JVM к поиску обходных решений. Язык Scala решает многие из недостатков языка Java, которые уменьшают его способность масштабирования.

Потоки Java

Потоки — это парадигма программирования, изобретенная Дж. Полом Родкер-Моррисоном в конце 60-х годов, в которой используется понятие «обработка данных» для проектирования и создания приложений. Поток Java определяет приложения как сети процессов, которые обмениваются данными с помощью блоков данных (информационных пакетов), перемещающихся по предопределенным соединениям. Эти процессы можно подключать бесконечно, чтобы сформировать приложения, не изменяя их внутреннее содержимое. Таким образом поток ориентируется на компонент.

Создание потока Java — это конкретная форма программирования Основана на ограниченных буферах, информационных пакетах с определенными сроками службы, именованных портах и отдельном определении соединений.

Процессы взаимодействуют через соединения, к которым обращаются через порты. Связи обычно реализуются через ограниченные буферы. Размер буфера или максимальное количество пакетов, которые может содержать очередь, называется пропускной способностью подключения. Некоторые реализации позволяют устанавливать соединения с емкостью 0, что означает, что IP-адреса данных немедленно передаются между процессами отправки и получения.

Определение

Потоковое программирование рассматривает приложение как набор процессов («черных ящиков»), связывающихся через соединения, к которым процессы обращаются с помощью портов. Процесс является экземпляром компонента, работающим одновременно с другими процессами, включая другие экземпляры одного и того же компонента.

Общий подход в потоковом программировании заключается в концептуализации программы как серии потоков и субпотоков, которые протекают через ряд связанных процессов. Параллелизм реализуется путем ограничения связи между процессами с использованием потоков информационных пакетов при завершении потока Java.

Визуальное программирование в этом контексте связано с подключением текстовых компонентов или графиков в двумерном представлении, которое использует возможности распознавания образов человека и визуальные стили мышления. Текстовое программирование по-прежнему доступно на уровне компонентов, а для простых приложений — на уровне сети.

Основными характеристиками являются повторное использование кода, тестируемость и параллельность.

Введение

Потоковое программирование определяет приложения с использованием метафоры «фабрика данных». Приложение рассматривается не как единый последовательный процесс, который начинается в определенный момент времени, а затем делает одну операцию в единицу времени до полного завершения, а как сеть асинхронных процессов, сообщающихся посредством потоков структурированных блоков данных, называемых информационными пакетами (IP). Сеть определяется внешними процессами как список соединений, которые интерпретируются частью программного обеспечения, обычно называемой планировщиком.

Процессы взаимодействуют через соединение с фиксированной емкостью. Соединение подключается к процессу с помощью порта, который имеет имя, согласованное между кодом процесса и сетевым определением. Один и тот же код может выполнять более одного процесса. В любой момент времени данный IP-адрес может принадлежать только одному процессу или находиться в пути между двумя процессами. Порты могут быть либо простыми, либо массивными.

Поскольку процессы потоков Java могут продолжать выполняться сколь угодно долго при наличии данных на ввод и вывод, приложения с применением этого метода обычно работают за меньшее время, чем обычные программы, и оптимально используют все процессоры на машине.

Сеть

Определение сети обычно схематично и преобразуется в список соединений на каком-либо языке или нотации более низкого уровня. Потоки ввода/вывода Java часто являются языком визуального программирования на этом уровне. Более сложные определения сетей имеют иерархическую структуру, которая создается из подсетей с гибкими соединительными связями. Другие примеры потоков Java основаны на более традиционных языках программирования. В частности RaftLib использует C ++ и iostream-подобные операторы для выполнения потока Java.

Описание процесса

Работа с потоками Java демонстрирует связывание данных как наиболее слабое соединение между компонентами. Концепция свободной связи, в свою очередь, связана с концепцией сервис-ориентированных архитектур. Пул потоков Java соответствует ряду критериев для такой архитектуры.

Потоковый метод способствует высокоуровневому функциональному стилю спецификаций, которые упрощают разработку гипотетических предпосылок поведения системы. Примером потоков Java является модель распределенного движения данных для конструктивного создания и анализа семантики распределенных протоколов.

Характеристики

Потоковое программирование обладает следующими уникальными свойствами:

    Структурность: диаграммы и компоненты имеют четкую структуру (интерфейс, состояние и поведение).

    Дизайн системы разделен на два слоя: графический (обычно визуальный) и компонентный (обычно текстовый). С точки зрения поощряются различные роли. В качестве примера: потоки Java управляются ролевыми функциями «Дизайнер графиков» и «Компонент-реализатор».

    Принцип параллелизма: каждый процесс выполняется в своем потоке, сопутствующей программе или другой среде.

    Активация — с точки зрения дизайнера точки графика процесса выполняются одновременно, а функция программного обеспечения планирования позволяет распределять процессорное время и управлять другими службами по мере необходимости, чтобы поддерживать этот функционал.

    Информационные пакеты при создании потока Java имеют жизненный цикл и принадлежат только одному процессу.

    Компоненты могут иметь несколько входов или выходов.

    Приложение представляет собой график, а не дерево. Разрешены циклические соединения (петли обратной связи).

    Соединения могут быть объединены в график, подразумевая, что пакеты из разных дуг поступают на входной порт. Соединения должны быть разделены через компонент из-за разнообразия стратегий разделения и правила владения IP.

    Соединения реализованы как ограниченные буферы с объемом от 0 до числа, ограниченного реализацией.

Примеры

Компоненты потоков данных Java часто образуют взаимодополняющие пары. В обычной логике программист быстро обнаруживает, что ни входные, ни выходные структуры не могут использоваться для управления иерархией вызовов потока управления. В потоках ввода Java само описание проблемы предлагает решение.

«Слова» явно указаны в описании проблемы, поэтому разработчику необходимо рассматривать их как информационные пакеты (IP). В потоках ввода Java нет единой иерархии вызовов, поэтому у программиста нет необходимости настраивать приоритезацию.

При создании потока Java исходные информационные пакеты (IIP) могут использоваться для указания параметрической информации, такой как желаемая длина выходной записи или имена файлов. IIP - это блоки данных, связанные с портом в определении сети, которые становятся «обычными» IP-адресами, когда «получаемый» параметр выдается для соответствующего порта.

Пакетное обновление

Этот тип программы включает передачу файла сведений (изменений, добавлений и удалений) на главный файл и создание обновленного основного файла и одного или нескольких отчетов. Новый поток Java довольно сложно кодировать с использованием синхронного процедурного кода, поскольку два (иногда более) потока ввода должны синхронизироваться.

В потоковой архитектуре компонент многократного использования значительно упрощает запись этого типа приложения, поскольку данный инструмент объединяет два потока и вставляет данные IP, чтобы указать уровни группировки. Предположим, что один или два потока Java состоят из IP-адресов с ключевыми значениями 1, 2 и 3, а IP-адреса второго потока имеет ключевые значения 11, 12, 21, 31, 32, 33 и 41, где первая цифра соответствует значениям главного ключа. Используя символы скобок для представления IP-адресов, собранный выходной поток будет выглядеть следующим образом: (m1 d11 d12) (m2 d21) (м3 d31 d32d33) (d41).

Процессы мультиплексирования

Потоковое программирование поддерживает мультиплексирование процессов. Поскольку компоненты доступны только для чтения, любое количество экземпляров данного компонента («процессы») может выполняться асинхронно друг с другом.

Когда компьютеры имели один процессор, это было полезно, когда много операций ввода-вывода потоков Java продолжалось. Теперь, когда машины имеют несколько процессоров, это становится действительно полезным инструментом. Потоки Java Thread работают по принципу многозадачности.

DrawFBP как инструмент

Потоковое программирование является парадигмой, где программы создаются из компонентов, которые имеют набор определенных входных и выходных портов. Эти порты соединяются вместе, чтобы составить график, определяющий логику и поток данных. DrawFBP — это настольное приложение, которое может определять графики программ на основе потоков для Java и C #. Это самый функционально полный пользовательский интерфейс потокового программирования, но он несколько ограничен возможностями межсетевого экрана Java и невозможностью интроспекции информации, доступной через интерфейс загрузки компонентов.

Ключевой частью пользовательского интерфейса является упрощение создания и понимания программ на основе метода потоков.

03.10.17 8.3K

В этом руководстве мы рассмотрим, как выполняется многопоточность Java , более подробно узнаем о потоках и синхронизации между ними.

Пример одного потока :

package demotest; public class GuruThread1 implements Runnable { /** * @param args */ public static void main(String args) { Thread guruThread1 = new Thread("Guru1"); Thread guruThread2 = new Thread("Guru2"); guruThread1.start(); guruThread2.start(); System.out.println("Thread names are following:"); System.out.println(guruThread1.getName()); System.out.println(guruThread2.getName()); } @Override public void run() { } }

Преимущества одного потока :

  • При выполнении одного потока снижается нагрузка на приложение;
  • Уменьшается стоимость обслуживания приложения.

Что такое многопоточность?

Многопоточность в Java - это выполнение двух или более потоков одновременно для максимального использования центрального процесса.

Многопоточные приложения - это приложения, где параллельно выполняются два или более потоков. Данное понятие известно в Java как многопотоковое выполнение. При этом несколько процессов используют общие ресурсы, такие как центральный процессор, память и т. д.

Все потоки выполняются параллельно друг другу. Для каждого отдельного потока не выделяется память, что приводит к ее экономии. Кроме этого переключение между потоками занимает меньше времени.

Пример многопоточности :

package demotest; public class GuruMultithread implements Runnable{ /** * @param args */ public static void main(String args) { Thread guruthread1 = new Thread(); guruThread1.start(); Thread guruthread2 = new Thread(); guruThread2.start(); } @Override public void run() { // TODO Автоматически сгенерированный метод stub } }

Преимущества многопоточности :

  • В задачах на многопоточность Java потоки выполняются независимо друг от друга, поэтому отсутствует блокирование пользователей, и можно выполнять несколько операций одновременно;
  • Одни потоки не влияют на другие, когда они наталкиваются на исключения.

Жизненный цикл потока в Java

Жизненный цикл потока :


Стадии жизни потока :
  1. Новый;
  2. Готовый к выполнению;
  3. Выполняемый;
  4. Ожидающий;
  5. Остановленный.
  1. Новый : в этой фазе поток создается с помощью класса Thread . Он остается в этом состоянии, пока программа его не запустит;
  2. Готовый к выполнению : экземпляр потока вызывается с помощью метода Start . Управление потоком предоставляется планировщику для завершения выполнения. От планировщика зависит то, следует ли запускать поток;
  3. Выполняемый : с началом выполнения потока его состояние изменяется на «выполняемый ». Планировщик выбирает один поток из пула потоков и начинает его выполнение в приложении;
  4. Ожидающий : поток ожидает своего выполнения. Поскольку в приложении выполняется сразу несколько потоков, необходимо синхронизировать их. Следовательно, один поток должен ожидать, пока другой поток не будет выполнен. Таким образом, это состояние называется состоянием ожидания;
  5. Остановленный : выполняемый поток после завершения процесса переходит в состояние «остановленный », известное также как «мертвый ».

Часто используемые методы для управления многопоточностью Java :

Например : В этом примере создается поток, и применяются перечисленные выше методы.

package demotest; public class thread_example1 implements Runnable { @Override public void run() { } public static void main(String args) { Thread guruthread1 = new Thread(); guruThread1.start(); try { guruthread1.sleep(1000); } catch (InterruptedException e) { // TODO Автоматически сгенерированный блок catch e.printStackTrace(); } guruthread1.setPriority(1); int gurupriority = guruthread1.getPriority(); System.out.println(gurupriority); System.out.println("Thread Running"); } }

Объяснение кода

Строка кода 2 : создаем класс «thread_Example1 Runnable » (готовый к выполнению ). Он должен быть реализован любым классом, экземпляры которого предназначены для выполнения потоком.
Строка 4 : переопределяется метод run для готового к запуску интерфейса, так как он является обязательным при переопределении этого метода.
Строка кода 6 : определяется основной метод, в котором начнется выполнение потока.
Строка кода 7 : создается новое имя потока «guruthread1 «, инициализируя новый класс потока.
Код строка 8 : используется метод «Start » в экземпляре «guruthread1 «. Здесь поток начнет выполняться.
Строка 10 : используется метод «sleep » в экземпляре «guruthread1 «. Поток приостановит свое выполнение на 1000 миллисекунд.
Строки 9-14 : применяется метод «sleep » в блоке «try catch », так как есть проверяемое исключение «Interrupted exception ».
Строка кода 15 : для потока назначается приоритет «1 », независимо от того, каким приоритет был до этого.
Строка кода 16 : получаем приоритет потока с помощью getPriority() .
Строка кода 17 : значение, извлеченное из getPriority .
Строка кода 18 : пишем текст, что поток выполняется.

Вывод

5 - это приоритет потока, а «Thread Running » - текст, который является выводом нашего кода.

Синхронизация потоков Java

В многопоточности Java присутствует асинхронное поведение. Если один поток записывает некоторые данные, а другой в это время их считывает, в приложении может возникнуть ошибка. Поэтому при необходимости доступа к общим ресурсам двум и более потоками используется синхронизация.

В Java есть свои методы для обеспечения синхронизации. Как только поток достигает синхронизированного блока, другой поток не может вызвать этот метод для того же объекта. Все другие потоки должны ожидать, пока текущий не выйдет из синхронизированного блока.

Таким образом, решается проблема в многопоточных приложениях. Один поток ожидает, пока другой не закончит свое выполнение, и только тогда другим потокам будет разрешено их выполнение.

Это можно написать следующим образом:

Synchronized(object) { //Блок команд для синхронизации }

Пример многопоточности Java

В этом Java многопоточности примере мы задействуем два потока и извлекаем имена потоков.

Пример 1

GuruThread1.java package demotest; public class GuruThread1 implements Runnable{ /** * @param args */ public static void main(String args) { Thread guruThread1 = new Thread("Guru1"); Thread guruThread2 = new Thread("Guru2"); guruThread1.start(); guruThread2.start(); System.out.println("Thread names are following:"); System.out.println(guruThread1.getName()); System.out.println(guruThread2.getName()); } @Override public void run() { } }

Объяснение кода

Строка кода 3 : задействуем класс «GuruThread1 «, который реализует интерфейс «Runnable » (он должен быть реализован любым классом, экземпляры которого предназначены для выполнения потоком ).
Строка 8 : основной метод класса.
Строка 9 : создаем класс Thread , экземпляр с именем «guruThread1 » и поток.
Строка 10 : создаем класс Thread , экземпляр с именем «guruThread2 » и поток.
Строка 11 : запускаем поток guruThread1 .
Строка 12 : запускаем поток guruThread2 .
Строка 13 : выводим текст «Thread names are following: «.
Строка 14 : получаем имя потока 1, используя метод getName() класса thread .
Строка кода 15 : получаем имя потока 2, используя метод getName() класса thread .

Вывод

Имена потоков выводятся как:

  • Guru1
  • Guru2

Пример 2

Из этого Java многопоточности урока мы узнаем о переопределяющих методах Run () и методе Start () интерфейса runnable . Создадим два потока этого класса и выполним их.

Также мы задействуем два класса:

  • Один будет реализовывать интерфейс runnable ;
  • Другой — с методом main и будет выполняться.

package demotest; public class GuruThread2 { public static void main(String args) { // TODO Автоматически сгенерированный метод stub GuruThread3 threadguru1 = new GuruThread3("guru1"); threadguru1.start(); GuruThread3 threadguru2 = new GuruThread3("guru2"); threadguru2.start(); } } class GuruThread3 implements Runnable { Thread guruthread; private String guruname; GuruThread3(String name) { guruname = name; } @Override public void run() { System.out.println("Thread running" + guruname); for (int i = 0; i < 4; i++) { System.out.println(i); System.out.println(guruname); try { Thread.sleep(1000); } catch (InterruptedException e) { System.out.println("Thread has been interrupted"); } } } public void start() { System.out.println("Thread started"); if (guruthread == null) { guruthread = new Thread(this, guruname); guruthread.start(); } } }

Объяснение кода

Строка кода 2 : принимаем класс «GuruThread2 «, содержащий метод main .
Строка 4 : принимаем основной метод класса.
Строки 6-7 : создаем экземпляр класса GuruThread3 (создается в строках внизу ) как «threadguru1 » и запускаем поток.
Строки 8-9 : создаем еще один экземпляр класса GuruThread3 (создается в строках внизу ) как «threadguru2 » и запускаем поток.
Строка 11 : для многопоточности Java создаем класс «GuruThread3 «, который реализует интерфейс «Runnable ». Он должен быть реализован любым классом, экземпляры которого предназначены для выполнения потоком.
Строки 13-14 : принимаем две переменные класса, из которых одна - потоковый класс, другая - строковый класс.
Строки 15-18 : переопределение конструктора GuruThread3 , который принимает один аргумент как тип String (являющийся именем потока ). Имя будет присвоено переменной класса guruname и сохраняется имя потока.
Строка 20 : переопределяется метод run() интерфейса runnable .
Строка 21 : выводится имя потока с использованием набора команд println .
Строки 22-31 : используется цикл «for » со счетчиком, инициализированным на «0 », который не должен быть меньше 4 . Выводится имя потока, а также выполняется приостановка потока на 1000 миллисекунд в блоке try-catch , поскольку метод sleep вызвал проверяемое исключение.
Строка 33 : переопределяется метод start интерфейса runnable .
Строка 35 : выводится текст «Thread started «.
Строки 36-40 : проверяем, содержит ли переменная класса guruthread значение. Если оно равно NULL , создается экземпляр класса thread . После этого запускается поток с использованием класса start() .

должны воспользоваться классом java.lang.Thread. В этом классе определены все методы, необходимые для создания потоков, управления их состоянием и синхронизации.

Как пользоваться классом Thread?

Есть две возможности.

  • Во-первых, вы можете создать свой дочерний класс на базе класса Thread. При этом вы должны переопределить метод run. Ваша реализация этого метода будет работать в рамках отдельного потока.
  • Во-вторых, ваш класс может реализовать интерфейс Runnable. При этом в рамках вашего класса необходимо определить метод run, который будет работать как отдельный поток.

Второй способ особенно удобен в тех случаях, когда ваш класс должен быть унаследован от какого-либо другого класса (например, от класса Applet) и при этом вам нужна многопоточность. Так как в языке программирования Java нет множественного наследования, невозможно создать класс, для которого в качестве родительского будут выступать классы Applet и Thread. В этом случае реализация интерфейса Runnable является единственным способом решения задачи.

Методы класса Thread

В классе Thread определены три поля, несколько конструкторов и большое количество методов, предназначенных для работы с потоками. Ниже мы привели краткое описание полей, конструкторов и методов.

С помощью конструкторов вы можете создавать потоки различными способами, указывая при необходимости для них имя и группу. Имя предназначено для идентификации потока и является необязательным атрибутом. Что же касается групп, то они предназначены для организации защиты потоков друг от друга в рамках одного приложения.

Методы класса Thread предоставляют все необходимые возможности для управления потоками, в том числе для их синхронизации.

Поля

Три статических поля предназначены для назначения приоритетов потокам.

  • NORM_PRIORITY

Нормальный

public final static int NORM_PRIORITY;
  • MAX_PRIORITY

Максимальный

public final static int MAX_PRIORITY;
  • MIN_PRIORITY

Минимальный

public final static int MIN_PRIORITY;

Конструкторы

Создание нового объекта Thread

public Thread();

Создвание нового объекта Thread с указанием объекта, для которого будет вызываться метод run

public Thread(Runnable target); public Thread(Runnable target, String name);

Создание объекта Thread с указанием его имени

public Thread(String name);

Создание нового объекта Thread с указанием группы потока и объекта, для которого вызывается метод run

public Thread(ThreadGroup group, Runnable target);

Аналогично предыдущему, но дополнительно задается имя нового объекта Thread

public Thread(ThreadGroup group, Runnable target, String name);

Создание нового объекта Thread с указанием группы потока и имени объекта

public Thread(ThreadGroup group, String name);

Методы

  • activeCount

Текущее количество активных потоков в группе, к которой принадлежит поток

public static int activeCount();
  • checkAccess

Текущему потоку разрешается изменять объект Thread

public void checkAccesss();
  • countStackFrames

Определение количества фреймов в стеке

public int countStackFrames();
  • currentThread

Определение текущего работающего потока

public static Thread currentThread();
  • destroy

Принудительное завершение работы потока

public void destroy();
  • dumpStack

Вывод текущего содержимого стека для отладки

public static void dumpStack();
  • enumerate

Получение всех объектов Tread данной группы

public static int enumerate(Thread tarray);
  • getName

Определение имени потока

public final String getName();
  • getPriority

Определение текущего приоритета потока

public final int getPriority();
  • getThreadGroup

Определение группы, к которой принадлежит поток

public final ThreadGroup getThreadGroup();
  • interrupt

Прерывание потока

public void interrupt();
  • interrupted
public static boolean interrupted();
  • isAlive

Определение, выполняется поток или нет

public final boolean isAlive();
  • isDaemon

Определение, является ли поток демоном

public final boolean isDaemon();
  • isInterrupted

Определение, является ли поток прерванным

public boolean isInterrupted();
  • join

Ожидание завершения потока

public final void join();

Ожидание завершения потока в течение заданного времени. Время задается в миллисекундах

public final void join(long millis);

Ожидание завершения потока в течение заданного времени. Время задается в миллисекундах и наносекундах

public final void join(long millis, int nanos);
  • resume

Запуск временно приостановленного потока

public final void resume();

Метод вызывается в том случае, если поток был создан как объект с интерфейсом Runnable

public void run();
  • setDaemon

Установка для потока режима демона

public final void setDaemon(boolean on);
  • setName

Устаовка имени потока

public final void setName(String name);
  • setPriority

Установка приоритета потока

public final void setPriority(int newPriority);
  • sleep
public static void sleep(long millis);

Задержка потока на заднное время. Время задается в миллисекундах и наносекундах

public static void sleep(long millis, int nanos);
  • start

Запуск потока на выполнение

public void start();
  • stop

Остановка выполнения потока

public final void stop();

Аварийная остановка выполнения потока с заданным исключением

public final void stop(Throwable obj);
  • suspend

Приостановка потока

public final void suspend();
  • toString

Строка, представляющая объект-поток

public String toString();
  • yield

Приостановка текущего потока для того чтобы управление было передано другому потоку

public static void yield();

Создание дочернего класса на базе класса Thread

Рассмотрим первый способ реализации многопоточности, основанный на наследовании от класса Thread. При использовании этого способа вы определяете для потока отдельный класс, например, так:

class DrawRectangles extends Thread { . . . public void run() { . . . } }

Здесь определен класс DrawRectangles, который является дочерним по отношению к классу Thread.

Обратите внимание на метод run. Создавая свой класс на базе класса Thread, вы должны всегда определять этот метод, который и будет выполняться в рамках отдельного потока.

Заметим, что метод run не вызывается напрямую никакими другими методами. Он получает управление при запуске потока методом start.

Как это происходит?

Рассмотрим процедуру запуска потока на примере некоторого класса DrawRectangles.

Вначале ваше приложение должно создать объект класса Thread:

public class MultiTask2 extends Applet { Thread m_DrawRectThread = null; . . . public void start() { if (m_DrawRectThread == null) { m_DrawRectThread = new DrawRectangles(this); m_DrawRectThread.start(); } } }

Создание объекта выполняется оператором new в методе start, который получает управление, когда пользователь открывает документ HTML с аплетом. Сразу после создания поток запускается на выполнение, для чего вызывается метод start.

Что касается метода run, то если поток используется для выполнения какой либо периодической работы, то этот метод содержит внутри себя бесконечный цикл. Когда цикл завершается и метод run возвращает управление, поток прекращает свою работу нормальным, не аварийным образом. Для аварийного завершения потока можно использовать метод interrupt.

Остановка работающего потока выполняется методом stop. Обычно остановка всех работающих потоков, созданных аплетом, выполняется методом stop класса аплета:

public void stop() { if (m_DrawRectThread != null) { m_DrawRectThread.stop(); m_DrawRectThread = null; } }

Напомним, что этот метод вызывается, когда пользователь покидает страницу сервера Web, содержащую аплет.

Реализация интерфейса Runnable

Описанный выше способ создания потоков как объектов класса Thread или унаследованных от него классов кажется достаточнао естественным. Однако этот способ не единственный. Если вам нужно создать только один поток, работающую одновременно с кодом аплета, проще выбрать второй способ с использованием интерфейса Runnable.

Идея заключается в том, что основной класс аплета, который является дочерним по отношению к классу Applet, дополнительно реализует интерфейс Runnable, как это показано ниже:

public class MultiTask extends Applet implements Runnable { Thread m_MultiTask = null; . . . public void run() { . . . } public void start() { if (m_MultiTask == null) { m_MultiTask = new Thread(this); m_MultiTask.start(); } } public void stop() { if (m_MultiTask != null) { m_MultiTask.stop(); m_MultiTask = null; } } }

Внутри класса необходимо определить метод run, который будет выполняться в рамках отдельного потока. При этом можно считать, что код аплета и код метода run работают одновременно как разные потоки.

Для создания потока используется оператор new. Поток создается как объект класса Thread, причем конструктору передается ссылка на класс аплета:

m_MultiTask = new Thread(this);

При этом, когда поток запустится, управление получит метод run, определенный в классе аплета.

Как запустить поток?

Запуск выполняется, как и раньше, методом start. Обычно поток запускается из метода start аплета, когда пользователь отображает страницу сервера Web, содержащую аплет. Остановка потока выполняется методом stop.

Чтобы создать поток вычислений в Jаvа-программе, следует начать с конструирования объекта класса Thread:

Thread worker = new Thread();

После того как объект Thread создан, его можно настроить и запустить на выполнение. Настройка потока включает в себя задание исходного приоритета выполнения, имени и Т.д. Когда объект готов к работе, вызывается его метод start. Метод start, используя данные объекта Thread, порождает новый поток Вычислений и завершает свое выполнение. Далее виртуальная машина Java вызывает метод run объекта и делает поток активным. Вызов start для каждого потока может быть осуществлен только один раз – повторное обращение приводит к выбрасыванию исключения типа i11ega1ThreadStateException.

Когда метод run возвращает управление, выполнение потока завершается. Прервать работу потока можно с помощью вызова метода interrupt – хорошо спроектированный поток всегда на него реагирует. Во время выполнения потока вы можете Взаимодействовать с ним и другими способами, о которых мы расскажем ниже.

Стандартная реализация метода Thread . run не предполагает выполнения каких бы то ни было действий. Чтобы заставить поток делать что-нибудь полезное, необходимо либо расширить класс Thread и предложить собственную пере

определенную версию метода гип, либо создать объект класса, производного от Runnable, и передать его конструктору потока в качестве аргумента. Сначала мы рассмотрим первый подход, связанный с расширением класса Thread. Вопросам использования объектов Runnablе посвящен следующий раздел.

Ниже приведен пример простой программы, предусматривающей создание двух потоков, которые выводят на экран слова "ping" и "PONG" с различной частотой.

public class РingPong extends Thread {

private String word; // Слово, подлежащее выводу на экран

private int delay; // величина временной задержки

public РingPong(String whatToSay, int delayTime) {

word = whatToSay;

delay = delayTime;

public void run() {

system.out.print(word + Thread.sleep(delay);

} catch (InterruptedException e)

return; // Завершить поток

Public static void main(Stringargs){

new PingPong(“ping”,33).start();

new PingPong(“ping”,100).start();

Мы определили новый класс РingPong, Производный от Thread. Метод гип содержит бесконечный цикл, в котором выполняются инструкции вывода слова word на экран и приостановки действия потока на период времени, заданный значением delay. Метод РingPong. гип не способен генерировать исключения, поскольку Никакие исключения не указаны в объявлении унаследованного метода Thread. тип. Тем не менее мы должны предусмотреть средства обработки исключения типа InterruptedException, которое может быть выброшено методом slеер (об исключении InterruptedException речь пойдет позже).

Теперь ничего не, мешает создать несколько потоков, и метод main – как раз то место, где можно это сделать. Мы создаем два объекта РingPong, передавая конструктору класса различные аргументы, представляющие слово и интервал задержки, и вызываем для каждого объекта метод start. Потоки активизируются и начинают выполняться. Вот как могут выглядеть результаты их работы:

ping PONG ping ping PONG ping ping ping PONG ping

ping PONG ping ping ping PONG ping ping PONG ping

pong ping PONG ping ping PONG ping ping ping PONG

plng ping PONG ping ping ping PONG ping ping PONG

ping ping ping PONG ping ping PONG ping ping ping

PONG ping ping PONG ping ping ping PONG ping ping

Потоку разрешено присвоить имя – либо с помощью аргумента String, передаваемого конструктору, либо посредством вызова метода setName. Текущее значение имени потока легко получить с помощью метода getName. Имена потоков служат только для удобства программиста (исполняющей системой они не используются) но поток должен обладать именем, и если оно не задано, исполняющая система принимает эту обязанность на себя, генерируя имена в соответствии с некоторым простым правилом, например thread_1, thread_2 и Т.д.

ссылку на объект Thread текущего выполняемого потока можно получить с помощью статического метода Thread. currentThread. Во время работы программы текущий. поток существует всегда, даже если вы не создавали Потоки явно – метод main активизируется с помощью потока, создаваемого исполняющей системой.

Упражнение 0.1. Напишите про грамму, которая отображает имя потока, выполняющего код метода main.