Java - Синхронизация

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

Java - Synchronization

Что такое Синхронизация и почему нам это нужно?

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

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

Необходимость в синхронизации потоков

Давайте рассмотрим реальный пример, чтобы понять, почему синхронизация так важна:

public class BankAccount {
private int balance = 1000;

public void withdraw(int amount) {
if (balance >= amount) {
System.out.println(Thread.currentThread().getName() + " is about to withdraw...");
balance -= amount;
System.out.println(Thread.currentThread().getName() + " has withdrawn " + amount);
} else {
System.out.println("Sorry, not enough balance for " + Thread.currentThread().getName());
}
}

public int getBalance() {
return balance;
}
}

В этом примере у нас есть простой класс BankAccount с методом withdraw. Похоже на просто, правда? Но что произойдет, когда два человека попытаются снять деньги одновременно? Давайте узнаем!

public class UnsynchronizedBankDemo {
public static void main(String[] args) {
BankAccount account = new BankAccount();

Thread john = new Thread(() -> {
account.withdraw(800);
}, "John");

Thread jane = new Thread(() -> {
account.withdraw(800);
}, "Jane");

john.start();
jane.start();

try {
john.join();
jane.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Final Balance: " + account.getBalance());
}
}

Когда вы запустите эту программу, можете увидеть что-то вроде этого:

John is about to withdraw...
Jane is about to withdraw...
John has withdrawn 800
Jane has withdrawn 800
Final Balance: -600

Подождите, что? Как мы могли получить отрицательный баланс? Это, мои друзья, называется гонка condition. И Джон, и Джейн проверили баланс, увидели, что денег достаточно, и сняли их. Точно поэтому нам нужна синхронизация!

Реализация Синхронизации в Java

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

Синхронизированные методы
Синхронизированные блоки

Синхронизированные методы

Самый простой способ добавить синхронизацию — использовать ключевое слово synchronized в объявлении метода. Давайте модифицируем наш класс BankAccount:

public class BankAccount {
private int balance = 1000;

public synchronized void withdraw(int amount) {
if (balance >= amount) {
System.out.println(Thread.currentThread().getName() + " is about to withdraw...");
balance -= amount;
System.out.println(Thread.currentThread().getName() + " has withdrawn " + amount);
} else {
System.out.println("Sorry, not enough balance for " + Thread.currentThread().getName());
}
}

public int getBalance() {
return balance;
}
}

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

John is about to withdraw...
John has withdrawn 800
Sorry, not enough balance for Jane
Final Balance: 200

Гораздо лучше! Только один поток может выполнить метод withdraw одновременно, предотвращая нашу раннюю проблему.

Синхронизированные блоки

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

public class BankAccount {
private int balance = 1000;
private Object lock = new Object(); // Это наш объект-замок

public void withdraw(int amount) {
synchronized(lock) {
if (balance >= amount) {
System.out.println(Thread.currentThread().getName() + " is about to withdraw...");
balance -= amount;
System.out.println(Thread.currentThread().getName() + " has withdrawn " + amount);
} else {
System.out.println("Sorry, not enough balance for " + Thread.currentThread().getName());
}
}
}

public int getBalance() {
return balance;
}
}

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

Важность правильной синхронизации

Теперь вы можете подумать: "Отлично! Я просто синхронизирую все!" Но подождите! Чрезмерная синхронизация может привести к проблемам с производительностью. Это как поставить светофор на каждом перекрестке в небольшом городе – это может быть безопасно, но также может замедлить все доcrawl.

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

Общие методы синхронизации

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

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

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

Заключение

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

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

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

Credits: Image by storyset

Предыдущий учебник:

Java - Хук выключения

Следующий учебник:

Java - Блокировка синхронизации