Java for Beginner
695 subscribers
605 photos
165 videos
12 files
938 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
Многопоточность

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

Параллелизм и конкурентность

Параллелизм: выполнение нескольких задач одновременно, например, на многоядерных процессорах.
Конкурентность: выполнение нескольких задач чередованием, для создания иллюзии одновременного выполнения на одноядерных процессорах.


Основные понятия многопоточности

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


Создание потоков

В Java создание потоков может быть реализовано двумя способами: наследованием класса Thread и реализацией интерфейса Runnable.

Наследование класса Thread

Создание класса, наследующего Thread:
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("MyThread is running");
}

public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // Запуск потока
}
}


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

Создание класса, реализующего Runnable:
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("MyRunnable is running");
}

public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start(); // Запуск потока
}
}


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

start(): запускает поток, вызывая метод run().
run(): содержит код, который выполнится в новом потоке.
sleep(long millis): приостанавливает выполнение потока на заданное количество миллисекунд.


public class MyThread extends Thread {
@Override
public void run() {
try {
Thread.sleep(1000); // Поток спит 1 секунду
System.out.println("Thread woke up");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


join(): ожидает завершения выполнения потока.

public class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread is running");
}

public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
try {
thread.join(); // Ожидание завершения потока
System.out.println("Thread has finished");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


isAlive(): возвращает true, если поток выполняется, иначе false.
MyThread thread = new MyThread();
thread.start();
System.out.println(thread.isAlive()); // true, если поток выполняется


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


Каждый поток в Java имеет приоритет, который влияет на порядок планирования потоков. Приоритеты варьируются от Thread.MIN_PRIORITY (1) до Thread.MAX_PRIORITY (10). Поток с более высоким приоритетом будет запланирован раньше, чем поток с более низким приоритетом.
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() {
System.out.println(getName() + " is running");
}

public static void main(String[] args) {
MyThread thread1 = new MyThread("Thread 1");
MyThread thread2 = new MyThread("Thread 2");

thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);

thread1.start();
thread2.start();
}
}


#Java #Training #Multithreading #Medium
Условные переменные

Condition — это интерфейс, предоставляющий средства для блокировки потоков до тех пор, пока они не будут сигнализировать другим потокам. Это более гибкая альтернатива методу wait() и notify() в синхронизированных блоках.
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBuffer {
private final Lock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();

private final Object[] items = new Object[100];
private int putptr, takeptr, count;

public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length) {
notFull.await();
}
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
count++;
notEmpty.signal();
} finally {
lock.unlock();
}
}

public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0) {
notEmpty.await();
}
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
count--;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}


#Java #Training #Multithreading #Medium
Многопоточность в Java: wait и notify

В Java методы wait(), notify(), и notifyAll() используются для управления потоками в многопоточной среде. Они позволяют потокам координировать свои действия при доступе к общим ресурсам, предоставляя механизм для ожидания и уведомления. Эти методы определены в классе Object и должны вызываться из синхронизированного контекста.

Метод wait()

Метод wait() заставляет текущий поток ждать до тех пор, пока другой поток не вызовет метод notify() или notifyAll() для этого объекта. Поток, вызвавший wait(), освобождает монитор и переходит в состояние ожидания.


Пример использования wait():
public class WaitNotifyExample {
private final Object lock = new Object();
private boolean condition = false;

public void doWait() {
synchronized (lock) {
while (!condition) {
try {
System.out.println("Waiting...");
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Condition met!");
}
}

public void doNotify() {
synchronized (lock) {
condition = true;
lock.notify();
System.out.println("Notified!");
}
}

public static void main(String[] args) {
WaitNotifyExample example = new WaitNotifyExample();

Thread waiter = new Thread(example::doWait);
Thread notifier = new Thread(example::doNotify);

waiter.start();
try {
Thread.sleep(1000); // Задержка для демонстрации ожидания
} catch (InterruptedException e) {
e.printStackTrace();
}
notifier.start();
}
}


Метод notify()

Метод notify() пробуждает один из потоков, ожидающих этого объекта. Выбор потока, который будет пробужден, не определяется, поэтому для пробуждения всех ожидающих потоков используется метод notifyAll().

Пример использования notify():
public class WaitNotifyExample {
private final Object lock = new Object();
private boolean condition = false;

public void doWait() {
synchronized (lock) {
while (!condition) {
try {
System.out.println("Waiting...");
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Condition met!");
}
}

public void doNotify() {
synchronized (lock) {
condition = true;
lock.notify();
System.out.println("Notified!");
}
}

public static void main(String[] args) {
WaitNotifyExample example = new WaitNotifyExample();

Thread waiter = new Thread(example::doWait);
Thread notifier = new Thread(example::doNotify);

waiter.start();
try {
Thread.sleep(1000); // Задержка для демонстрации ожидания
} catch (InterruptedException e) {
e.printStackTrace();
}
notifier.start();
}
}


#Java #Training #Multithreading #Medium