При программировании программного обеспечения мы должны учитывать время выполнения и различные задачи, которые пользователь выполняет, чтобы они не были слишком медленными, в некоторых случаях экраны использовались, чтобы отвлечь пользователя сообщениями типа «Загрузка
«Процесс может занять несколько минут
"и другие известные сообщения.
В большинстве случаев программное обеспечение использует всю оперативную память и процессор, блокируя другие задачи или даже полностью отключая компьютер. Это происходит потому, что процесс выполняется на переднем или заднем плане, потребляя все ресурсы и блокируя другие процессы. Одним из способов решения этой проблемы является использование многозадачности, используя тот факт, что компьютеры имеют более одного процессора. Если мы запрограммируем наше приложение с помощью многозадачных методов, компьютер не будет заблокирован, хотя он будет работать медленнее, но пользователь сможет продолжить выполнение другого приложения, поскольку процессоры могут реагировать на разные потоки, работая параллельно.
Поток или Поток - это часть кода, которая имеет характеристику параллельного выполнения, то есть одновременно с другой частью кода. Он также имеет аппаратное ограничение, поскольку многозадачность зависит от количества ядер, которые имеет процессор, то есть, если он имеет 2 ядра, он может выполнять две задачи одновременно.
Есть две плоскости выполнения для программного обеспечения - передний план и задний план.
Передний план или передний план - это то, что пользователь видит на своем экране и работает с кнопками, окнами, текстовыми полями, изображениями и т. Д. Наиболее распространенные вычисления выполняются на переднем плане или в главном потоке приложения. Здесь мы должны помнить, что если у нас очень тяжелый дизайн со слишком большим количеством графики, пользователь может почувствовать, что приложение работает медленно и связано не с многозадачностью, а с ресурсами, которые оно потребляет для отображения каждого экрана.
В настоящее время многие программы предупреждают, что если приложение потребляет слишком много ресурсов или ставит под угрозу стабильность системы, а другие прямо закрывают приложение, которое вызывает проблемы, такие как Android, где в случае, если программа или программное обеспечение блокирует устройство более чем на 5 секунд, оно запускает предупреждающее сообщение или в худшем случае программа закроется, сообщая, что приложение остановлено. В Firefox, если веб-сайт работает очень медленно, обычно появляются предупреждающие сообщения, сценарий не отвечает или принудительно закрывается.
Фон или Фон, это где потоки или многозадачность обрабатываются . Хотя отображается некоторый экран, в фоновом режиме мы должны выполнить все тяжелые процессы, здесь пользователь не видит, что происходит, где выполняются программные службы, сетевые ссылки, соединения с базой данных, сложные вычисления. и т. д. Здесь процессы могут занимать необходимое время, пока пользователь выполняет другие задачи.
Как создать многопоточное приложение
Первый метод создания потока - это расширение класса Thread, уже существующего в Java, а затем добавление кода, который мы хотим выполнить, в метод run ().
класс Myplication extends Thread {public void run () {// Процесс для выполнения} System.out.println («Этот процесс завершен»); } Это тот случай, когда мы определили Мое приложение, которое расширяет класс Thread и использует метод run () для предоставления функциональности выполнения в этом классе. Расширяя класс Thread, вы можете наследовать методы и переменные родительского класса. Начать тему или тему
Java-приложения выполняют метод main () при запуске, и здесь мы также запускаем необходимые потоки для нашего приложения, если только нам не нужны требования, которые какое-либо событие вводит в действие.
Например, предположим, что у нас есть класс, который выходит из Thread, и мы создаем новые потоки и запускаем их
public static void main (String [] args) {Поток класса Thread A = новый поток класса ("Thread A"); Поток класса B - новый поток класса («Thread B»); провод A.start (); поток B.start (); } Значения, которые мы назначаем каждому потоку, составляют имя каждого потока или потока для запуска. Приостановить выполнение потока или потока
Возможно, нам потребуется остановить выполнение потока, если нам понадобится выполнить еще одну задачу, чтобы продолжить ее позже, для этого используется метод подвески (), его можно возобновить с помощью метода start ().
thread.suspend ();Остановить выполнение потока или потока
С помощью метода stop () мы можем остановить выполнение потока, необходимо учитывать, что его нельзя возобновить с помощью метода start (). Когда переменные, используемые в потоке, освобождаются, объект потока (созданный с помощью new) будет помечен для его удаления, и сборщик мусора будет отвечать за освобождение используемой памяти.
thread.stop ();Нам также может понадобиться определить, работает ли непрерывный поток или поток независимо от того, как долго завершился назначенный ему процесс, мы можем использовать метод isAlive ().
thread.isAlive ();Давайте посмотрим на пример многопоточного приложения, разработанного с помощью Netbeans, начнем с создания приложения.
Мы присваиваем имя нашему проекту в этом случае Hilo при запуске потока class.java у нас будет метод main по умолчанию
пакетные нитки; Открытый класс Threads {public static void main (String [] args) {// Вся логика приложения кода здесь}} Теперь мы перейдем к добавлению класса, который будет обрабатывать наши потоки. Предположим, что у нас есть три области: область клиентов компании, область платежей и область продаж, и каждая из них должна обрабатывать 20 операций - либо продажи, либо обслуживание клиентов, либо платежи и все должны быть обработаны сервером. Затем мы создадим расширяющий класс класса Thread, и он будет называться Procesarhilo.
пакетные нитки; открытый класс Поток обработки расширяет Thread {// переменная сообщения - это параметр, который мы назначим вам в области, которую обрабатываем Message String; public Procesarhilo (String message) {this.message = message; } // Функция run выполняет потоки public void run () {for (int i = 1; i <= 20; i ++) {// Мы показываем обрабатываемую область System.out.println (message + "" + i ); // Мы показываем предупреждение о том, что поток завершил обработку System.out.println ("Процесс:" + "" + i + "закончено"); }} public void Assign Message (String message) {this.message = message; }} Затем мы переходим к основному классу threads.java и создаем экземпляры потоков, которые будут обработаны: 
Затем мы запустим программу и увидим в текстовом выводе, как выполняются потоки, результатом будет следующее:
Давайте проанализируем, как обрабатывались потоки:
Процесс зоны клиента 1
Клиентская область Процесс 2
Процесс работы с клиентом 3
Процесс работы с клиентом 4
Процесс работы с клиентом 5
Процесс работы с клиентом 6
Процесс работы с клиентом 7
..
Процесс в области клиента 16 - Процесс: 16 завершен
Пока клиент 16 обрабатывается последовательно, но здесь начинается процесс оплаты
Платежный процесс 1
,
Процесс оплаты 10
До тех пор, пока не будет выполнен процесс оплаты 10, а затем начнется процесс продажи
Торговая зона Процесс 1
...
Торговая зона Процесс 15
В процессе 15 он принимает процесс оплаты 11 до его завершения
Процесс оплаты 11
,
Платежный процесс 20
Затем продолжите процесс клиентов, где я ухожу и закончить
Процесс работы с клиентом 17
,
Процесс клиентской зоны 20
Торговая зона Процесс 16
Процесс продаж 20
Наконец, он завершается тем, что все потоки принимают процесс продаж до завершения, поэтому мы можем видеть, как 60 назначенных задач выполнялись не последовательно, а с помощью контроля над ресурсами в течение короткого периода времени, чтобы все задачи могли быть выполнены в многозадачность.
- 0
СТАТЬИ