Java потоки синхронизация: Синхронизация потоков, блокировка объекта и блокировка класса

Содержание

Синхронизация потоков. Курс «Программирование на Java»

В многопоточной программе не всегда один поток работает независимо от другого. Бывает, они обмениваются данными или обрабатывают одни и те же объекты.

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

Синхронизация потоков – это настройка их взаимодействия. Рассмотрим пример, в котором два разных потока работают с одним и тем же объектом:

public class NoSynch {
    public static void main(String[] args) 
           throws InterruptedException {
        Client client = new Client(1000);
        Thread operation = 
                  new Operation(client, 1000);
        Thread operation1 = 
                  new Operation(client, 500);
        operation.start();
        operation1.start();
        operation.join();
        operation1.join();
        System. out.println(client.getBill());
    }
}
 
class Operation extends Thread {
    private Client mClient;
    private int mPay;
 
    Operation(Client client, int pay) {
        mClient = client;
        mPay = pay;
    }
 
    @Override
    public void run() {
        System.out.println(this.getName() + 
                   ": " + mClient.getBill());
        if (mClient.getBill() - mPay >= 0) {
            try {
                sleep(1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            mClient.changeBill(mPay);
        }
        System.out.println(this.getName() + 
                    ": " + mClient.getBill());
        System.out.println(this.getName() + " stop");
    }
}
 
class Client {
    private int mBill;
 
    Client(int bill) {
        this.mBill = bill;
    }
 
    int getBill() {
        return mBill;
    }
 
    void changeBill(int pay) {
        mBill -= pay;
    }
}

Результат:

Thread-0: 1000
Thread-1: 1000
Thread-0: 0
Thread-0 stop
Thread-1: -500
Thread-1 stop
-500

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

У клиента на счету оказалась отрицательная сумма, хотя по логике вещей одна из операций вычитания не должна была бы выполняться. Проблема возникла из-за того, что в каждом потоке на момент проверки (mClient.getBill() - mPay >= 0) было по 1000 на счету. И каждый поток «решил», что денег достаточно. После этого поток-0 уменьшил сумму. Когда поток-1 приступил к вычитанию, денег на счету уже не было.

Чтобы исключить подобную логическую ошибку, надо как-то блокировать объект client, чтобы пока он обрабатывается в одном потоке, другие не могли его изменять. Как вариант делать это в методе в run():

class Operation extends Thread {
    private final Client mClient;
    private int mPay;
 
    Operation(Client client, int pay) {
        mClient = client;
        mPay = pay;
    }
 
    @Override
    public void run() {
        System. out.println(this.getName() + 
                   ": " + mClient.getBill());
        synchronized (mClient) {
            if (mClient.getBill() - mPay >= 0) {
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mClient.changeBill(mPay);
            }
        }
        System.out.println(this.getName() + 
                   ": " + mClient.getBill());
        System.out.println(this.getName() + " stop");
    }
}

Результат:

Thread-0: 1000
Thread-1: 1000
Thread-0: 0
Thread-0 stop
Thread-1: 0
Thread-1 stop
0

И хотя оба потока сначала увидели 1000. Когда началась проверка и вычитание, действия выполнялись совместно, другой поток в это время доступ к объекту не имел.

Блок кода с ключевым словом synchronized может одновременно выполняться только одним потоком.

В примере синхронизация выполнена по объекту. В Java также возможна синхронизация по методу, т. е. пока методом пользуется один поток, другому он недоступен. Если в вышеприведенной программе мы по отдельности синхронизируем методы getBill() и changeBill() объекта, это ничего не даст. Решением может быть объединение проверки и вычитания в один метод:

class Operation1 extends Thread {
    private Client1 mClient;
    private int mPay;
    Operation1(Client1 client, int pay) {
        mClient = client;
        mPay = pay;
    }
 
    @Override
    public void run() {
        try {
            sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mClient.changeBill(mPay);
    }
}
 
class Client1 {
    private int mBill;
    Client1(int bill) {
        this.mBill = bill;
    }
 
    synchronized void changeBill(int pay) {
        System.out.println(mBill);
        if (mBill-pay >= 0) {
            mBill -= pay;
            System.out.println(mBill);
        }
    }
}

У каждой нити есть собственный кэш, куда копируются данные, с которыми она работает. Таким образом, одна нить не имеет доступа к данным другой и не может прочитать произошедшие изменения, а читает устаревшие значения из обычной памяти. Если потоки работают с общими данными, можно запретить их помещение в кэш, используя ключевое слово volatile. Например:

private volatile int mBill;

Синхронизация Потоков Java (Разные Стеки)

нестатические переменные существуют в разных местах в памяти для каждого потока

Это неверно, поэтому ответ на

если код, который выполняет поток, содержит некоторую переменную класса v1, тогда каждый поток имеет свой собственный «экземпляр» v1 (другой адрес памяти), и ни один другой поток не может «коснуться» его… не так ли

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

Переменные члена класса существуют в одном месте в памяти для каждого класса, а не в потоке. Это правда, что между барьерами памяти (подумайте о начале { и конце } of synchronized), что поток может иметь кеш состояния объекта, но это не то же самое, что и язык, требующий хранения на потоке. «Память для каждого потока» — это его стек, который не содержит элементов объекта * — только ссылки на объекты.

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

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

Локальное распределение потоков
Если распределитель действительно реализован, как показано в листинге 1, общее поле heapStart быстро станет значительным узким местом concurrency, так как каждое распределение будет включать в себя блокировку, защищающую это поле. Чтобы избежать этой проблемы, большинство JVM используют поточно-локальные блоки распределения, где каждый поток распределяет большую часть памяти из кучи и запросов на мелкие запросы обслуживания последовательно из этого потока-локального блока. В результате количество раз, когда поток должен получить общую блокировку кучи, значительно уменьшается, улучшая concurrency.

* — возможно, что оптимизация JVM позволяет некоторым объектам быть выделенными в стеке.

Что такое синхронизация Java?

В информатике поток представляет собой последовательность инструкций внутри программы, которые могут выполняться независимо от другого кода. Многие потоки могут запускаться одновременно внутри программы. Все Java-программы имеют по крайней мере один поток, известный как основной поток, который создается JVM при запуске программы, когда метод main() вызывается с основным потоком. Это объект, который имеет свои собственные регистры, стек и сегмент кода, которые могут работать параллельно с другими потоками процесса (процесс представляет собой набор потоков).

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

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

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

В общем случае синхронизация используется для защиты доступа к ресурсам, к которым обращаются одновременно. Одним из преимуществ использования нескольких потоков в приложении является то, что каждый поток выполняется асинхронно. Существует много ситуаций, когда несколько потоков должны совместно использовать доступ к общим объектам. Например, в системе базы данных вам может не потребоваться, чтобы один поток обновлял запись базы данных, а другой поток пытался ее прочитать. В этих случаях мы должны гарантировать, что ресурс будет использоваться только по одному потоку за раз. В противном случае два или более потока могут получить доступ к одному и тому же ресурсу в одно и то же время, каждый не знает о действиях другого. Java позволяет вам координировать действия нескольких потоков с использованием синхронизированных методов и синхронизированных операторов. Доступ к объекту, для которого нужно координировать доступ, осуществляется посредством использования синхронизированных методов. Эти методы объявляются с ключевым словом synchronized. Только один синхронизированный метод может быть вызван для объекта в данный момент времени. Это позволяет синхронизировать методы в нескольких потоках от конфликта друг с другом. Ниже приведен общий вид синхронизированного оператора:

Синтаксис

synchronized(objectidentifier) {
// Доступ к общим переменным и другим общим ресурсам
}

synchronized(objectidentifier) {

// Доступ к общим переменным и другим общим ресурсам

}

Параметр objectidentifier является ссылкой на объект, блокировка которого связана с монитором, который представляет собой синхронизированный оператор. Язык программирования Java предоставляет две основные идиомы синхронизации: синхронизированные методы и синхронизированные операторы.

Что такое синхронизированные методы и синхронизированные операторы?

Синхронизированные методы позволяют простую стратегию предотвращения помех потоков и ошибок согласованности памяти: если объект виден более чем одному потоку, все считывания или записи в переменные этого объекта выполняются с помощью синхронизированных методов. Невозможно чередование двух вызовов синхронизированных методов на одном объекте. Когда один поток выполняет синхронизированный метод для объекта, все другие потоки, которые вызывают синхронизированные методы для одного и того же блока объектов (приостанавливают выполнение) до тех пор, пока первый поток не будет выполнен с объектом. Чтобы синхронизировать метод, просто добавьте синхронизированное ключевое слово в его объявление:

public synchronized void increament(){
count++;
}

public synchronized void increament(){

count++;

}

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

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

public void add(int value){
synchronized(this){
this.count += value;
}
}

public void add(int value){

synchronized(this){

this.count += value;

}

Одно существенное различие между синхронизированным методом и блоком состоит в том, что Синхронизированный блок обычно уменьшает объем блокировки. Поскольку объем блокировки обратно пропорционален производительности, всегда лучше блокировать только критический раздел кода. Кроме того, синхронизированный блок может вызывать Java.lang.NullPointerException, если выражение, предоставленное блоку, как параметр, имеет значение null, что не соответствует синхронным методам.

Источник: http://net-informations. com/Java/cJava/synchronization.htm

Потоки и синхронизация — ni0xx

Безопасность потоков

Если несколько потоков обращаются к одной изменяемой переменной без соответсвующей синхронизации, программа сломана. Есть 3 способа это исправить:

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

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

Атомарность (Atomicy)

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

Классы, реализующий атомарные потоко-безопасные операции находятся в пакете
java.util.concurrent.atomic

Блокировка (Locking)

synchronized методы ( == synchronized(this) {} или вместо this -> class для static )
syncronized блоки

Совместное использование объектов

Видимость

public class NoVisibility {
    private static boolean ready;
    private static int number;
    private static class ReaderThread extends Thread {
        public void run() {
            while (!ready)
                Thread.yield();
            System.out.println(number);
        }
}
    public static void main(String[] args) {
        new ReaderThread().start();
        number = 42;
        ready = true;
} }

NoVisibility может иметь бесконечный цикл, поскольку видимость ready может никогда не стать видимымой для ReaderThread.
Даже NoVisibility может вывести 0, так как запись в ready может стать видимой для readerthread до того, как записи в number. Это явление известно как reodering.
Не существует никакой гарантии, что операции в одном потоке будут осуществляться в порядке, указанном в программе, пока их порядок не обнаруживается внутри этого потока, даже если изменение порядка очевидно для других потоков

Устаревший данные (Stale data)

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

Публикация объектов

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

Техника ограничения потоков

Ограничения в объявлении (Ad-hoc Thread Confinement) на уровне интерфейса и документации — Переложить заботу о синхронизации на разработчика/имплементатора (например Swing)
Использование стэка (Stack Confinement) Создание и использование только локальных экземпляров внутри метода(ов)
Использование ThreadLocal

private static ThreadLocal<Connection> connectionHolder
    = new ThreadLocal<Connection>() {
        public Connection initialValue() {
            return DriverManager. getConnection(DB_URL);
} };
public static Connection getConnection() {
    return connectionHolder.get();
}

Для каждого потока будет создаваться один свой Connection

<back

Неизменяемость (Immutability)

Неизменяемые объекты всегда потоко-безопасны
Объект не изменяем если:

Его состояние не может быть изменено после создания
Все его поля объявлены как final
Объект правильно создан (нет потери this в конструкторе)

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

Инициализация ссылки на объект с помощью статического инициализатора
Сохранение ссылки на объект с помощью volatile поля или AtomicReference
Сохранение ссылки на объект в final поле правильно построенного объекта; или
Сохранение ссылки на объект в поле, защищенное блокировкой (синхронизацией)

Составление объектов (Composing objects)

Процесс проектирования потоко-безопасногоо класса включает 3 основных элемента:

Определить переменные, которые формируют состояние объекта
Определить инварианты, которые ограничивают переменные состояния
Задожить политику управления конкурентным доступом к состоянию объекта

Избегать синхронизации (это) в Java?

Мои два цента в 2019 году, хотя этот вопрос уже мог быть решен.

Блокировка «this» — это неплохо, если вы знаете, что делаете, но за сценой стоит блокировка «this» (что, к сожалению, позволяет синхронизированное ключевое слово в определении метода).

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

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

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

Нельзя утверждать, что «как правило» вы не хотите, чтобы пользователи вашего класса могли делать такие вещи, или что «обычно» вы хотите . .. Это зависит от того, какую функциональность вы кодируете. Вы не можете сделать правило большого пальца, поскольку вы не можете предсказать все варианты использования.

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

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

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

Примечание 2: я не согласен с аргументом, что если какой-то код случайно украл вашу блокировку, это ошибка, и вы должны ее решить. В некотором смысле это тот же аргумент, что и я могу сделать все мои методы публичными, даже если они не предназначены для публичности. Если кто-то «случайно» называет мой метод закрытым, это ошибка. Зачем включать эту аварию в первую очередь !!! Если способность украсть ваш замок — проблема для вашего класса, не позволяйте это. Так просто.

Параллелизм в Java | Блог только про Java

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

Допустим, один поток исполнения входит в монитор объекта Х, а другой — в монитор объекта У. Если поток исполнения в объекте Х попытается вызвать любой синхронизированный метод для объекта У, он будет блокирован, как и предполагалось. Читать →