Quartz Job вызов синхронизированного метода до завершения первого [дублирования]

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

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

Object.wait()

Обзор

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

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

Deeper

Синтаксис ключевого слова synchronized принимает Object как его параметр (называемый объект блокировки ), за которым затем следует { block of code }.

• Когда выполнение встречает это ключевое слово, текущий поток пытается «заблокировать / приобрести / (возьмите свой выбор) объекта блокировки и выполните соответствующий блок кода после того, как блокировка была получена.
• Любая запись в переменные внутри синхронизированного блока кода гарантированно будет видна для каждого другого потока, который аналогичным образом выполняет код внутри синхронизированного кодового блока с использованием того же объекта блокировки .
• Только один поток за раз может удерживать блокировку, за это время все остальные потоки пытаясь приобрести e тот же объект блокировки будет ждать (приостановить их выполнение).

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

Добавление ключевого слова synchronized в определение метода равно всему телу метода завершается в синхронизированном блоке кода с объектом lock , являющимся this (например, методами) и ClassInQuestion.getClass() (для методов класса) .

- Метод экземпляра - это метод, который не имеет ключевого слова static. - Метод класса - это метод, имеющий ключевое слово static.

Technical

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

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

Заключение

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

Источники

http: //docs.oracle.com/javase/specs/jls/se8/html/index.html Спецификация языка Java®, 2015-02-13

Ну, я думаю, что у нас было достаточно теоретических объяснений, поэтому рассмотрим этот код

public class SOP {
    public static void print(String s) {
        System.out.println(s+"\n");
    }
}

public class TestThread extends Thread {
    String name;
    TheDemo theDemo;
    public TestThread(String name,TheDemo theDemo) {
        this.theDemo = theDemo;
        this.name = name;
        start();
    }
    @Override
    public void run() {
        theDemo.test(name);
    }
}

public class TheDemo {
    public synchronized void test(String name) {
        for(int i=0;i<10;i++) {
            SOP.print(name + " :: "+i);
            try{
                Thread.sleep(500);
            } catch (Exception e) {
                SOP.print(e.getMessage());
            }
        }
    }
    public static void main(String[] args) {
        TheDemo theDemo = new TheDemo();
        new TestThread("THREAD 1",theDemo);
        new TestThread("THREAD 2",theDemo);
        new TestThread("THREAD 3",theDemo);
    }
}

. Примечание: synchronized блокирует вызов следующего потока метода test () до тех пор, пока выполняется предыдущий поток не завершено. Потоки могут получить доступ к этому методу по одному за раз. Без synchronized все потоки могут одновременно обращаться к этому методу.

Когда поток вызывает синхронизированный метод «test» объекта (здесь объект является экземпляром класса «TheDemo»), он приобретает блокировку этого объект, любой новый поток не может вызвать ЛЮБОЙ синхронизированный метод того же объекта, пока предыдущий поток, который приобрел блокировку, не освобождает блокировку.

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

Выход с синхронизированным

THREAD 1 :: 0
THREAD 1 :: 1
THREAD 1 :: 2
THREAD 1 :: 3
THREAD 1 :: 4
THREAD 1 :: 5
THREAD 1 :: 6
THREAD 1 :: 7
THREAD 1 :: 8
THREAD 1 :: 9
THREAD 3 :: 0
THREAD 3 :: 1
THREAD 3 :: 2
THREAD 3 :: 3
THREAD 3 :: 4
THREAD 3 :: 5
THREAD 3 :: 6
THREAD 3 :: 7
THREAD 3 :: 8
THREAD 3 :: 9
THREAD 2 :: 0
THREAD 2 :: 1
THREAD 2 :: 2
THREAD 2 :: 3
THREAD 2 :: 4
THREAD 2 :: 5
THREAD 2 :: 6
THREAD 2 :: 7
THREAD 2 :: 8
THREAD 2 :: 9

Выход без синхронизации

THREAD 1 :: 0
THREAD 2 :: 0
THREAD 3 :: 0
THREAD 1 :: 1
THREAD 2 :: 1
THREAD 3 :: 1
THREAD 1 :: 2
THREAD 2 :: 2
THREAD 3 :: 2
THREAD 1 :: 3
THREAD 2 :: 3
THREAD 3 :: 3
THREAD 1 :: 4
THREAD 2 :: 4
THREAD 3 :: 4
THREAD 1 :: 5
THREAD 2 :: 5
THREAD 3 :: 5
THREAD 1 :: 6
THREAD 2 :: 6
THREAD 3 :: 6
THREAD 1 :: 7
THREAD 2 :: 7
THREAD 3 :: 7
THREAD 1 :: 8
THREAD 2 :: 8
THREAD 3 :: 8
THREAD 1 :: 9
THREAD 2 :: 9
THREAD 3 :: 9

synchronized означает, что в многопоточной среде объект, имеющий synchronized метод (ы) / блок (ы), не пропускает два потока для доступа к synchronized методу (-ам) / блоку кода одновременно. Это означает, что один поток не может читать, пока другой поток обновляет его.

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

Если ваше приложение однопоточно, но блоки synchronized не предоставляют преимуществ.

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

class MyRunnable implements Runnable {
    int var = 10;
    @Override
    public void run() {
        call();
    }

    public void call() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                var++;
                System.out.println("Current Thread " + Thread.currentThread().getName() + " var value "+var);
            }
        }
    }
}

public class MutlipleThreadsRunnable {
    public static void main(String[] args) {
        MyRunnable runnable1 = new MyRunnable();
        MyRunnable runnable2 = new MyRunnable();
        Thread t1 = new Thread(runnable1);
        t1.setName("Thread -1");
        Thread t2 = new Thread(runnable2);
        t2.setName("Thread -2");
        Thread t3 = new Thread(runnable1);
        t3.setName("Thread -3");
        t1.start();
        t2.start();
        t3.start();
    }
}

Мы создали два объекта класса MyRunnable, runnable1 - совместно с потоком 1 и потоком 3 & amp; runnable2 используется только для потока 2. Теперь, когда t1 и t3 запускаются без использования синхронизации, вывод PFB, который предполагает, что оба потока 1 и 3 одновременно влияют на значение var, где для потока 2, var имеет свою собственную память.

Without Synchronized keyword

    Current Thread Thread -1 var value 11
    Current Thread Thread -2 var value 11
    Current Thread Thread -2 var value 12
    Current Thread Thread -2 var value 13
    Current Thread Thread -2 var value 14
    Current Thread Thread -1 var value 12
    Current Thread Thread -3 var value 13
    Current Thread Thread -3 var value 15
    Current Thread Thread -1 var value 14
    Current Thread Thread -1 var value 17
    Current Thread Thread -3 var value 16
    Current Thread Thread -3 var value 18

Использование Synchronzied, thread 3 ожидание завершения потока 1 во всех сценариях. Имеются две блокировки: одна на runnable1, совместно используемая нитью 1 и потоком 3, а другая на runnable2, совместно используемая только потоком.

Current Thread Thread -1 var value 11
Current Thread Thread -2 var value 11
Current Thread Thread -1 var value 12
Current Thread Thread -2 var value 12
Current Thread Thread -1 var value 13
Current Thread Thread -2 var value 13
Current Thread Thread -1 var value 14
Current Thread Thread -2 var value 14
Current Thread Thread -3 var value 15
Current Thread Thread -3 var value 16
Current Thread Thread -3 var value 17
Current Thread Thread -3 var value 18

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

Synchronized normal method, эквивалентный Synchronized statement (используйте это)

class A {
    public synchronized void methodA() {
        // all function code
    }

    equivalent to

    public void methodA() {
        synchronized(this) {
             // all function code
        }
    } 
}

Synchronized static method, эквивалентный Synchronized statement (использовать класс)

class A {
    public static synchronized void methodA() {
        // all function code
    }

    equivalent to

    public void methodA() {
        synchronized(A.class) {
             // all function code
        }
    } 
}

Синхронизированный оператор ( используя переменную)

class A {
    private Object lock1 = new Object();

    public void methodA() {
        synchronized(lock1 ) {
             // all function code
        }
    } 
}

Для synchronized мы имеем оба Synchronized Methods и Synchronized Statements. Однако Synchronized Methods подобен Synchronized Statements, поэтому нам просто нужно понять Synchronized Statements.

=> В принципе, мы будем иметь

synchronized(object or class) { // object/class use to provides the intrinsic lock
   // code 
}

. Здесь 2 считают, что help synchronized

• У каждого объекта / класса есть intrinsic lock, связанный с ним.
• Когда поток вызывает synchronized statement, он автоматически получает intrinsic lock для этого объекта synchronized statement's и освобождает его при возврате метода. Пока нить принадлежит intrinsic lock, ни один другой поток не может получить SAME lock => thread safe.

=> Когда thread A вызывает synchronized(this){// code 1} => все блочный код (внутри класса), где synchronized(this) и все synchronized normal method (внутри класса) заблокированы, потому что SAME заблокирован. Он будет выполнен после разблокировки thread A («// код 1» завершен).

Это поведение похоже на synchronized(a variable){// code 1} или synchronized(class).

SAME LOCK => lock (не зависит от какого метода? или каких операторов?)

Использовать синхронизированный метод или синхронизированные операторы?

Я предпочитаю synchronized statements потому что он более расширяем. Например, в будущем вам потребуется только синхронизация части метода. Например, у вас есть 2 синхронизированный метод, и он не имеет никакого отношения друг к другу, однако, когда поток запускает метод, он блокирует другой метод (он может предотвратить использование synchronized(a variable)).

Однако применять синхронный метод просто и код выглядит просто. Для некоторого класса существует только один синхронизированный метод или все синхронизированные методы в классе, относящиеся друг к другу => мы можем использовать synchronized method, чтобы сделать код короче и легко понятным

Примечание

(это мало относится к synchronized, оно отличается от объекта и класса или нестатического и статического).

• Когда вы используете synchronized или обычный метод, или synchronized(this) или synchronized(non-static variable), он будет синхронизироваться с базой на каждом экземпляре объекта.
• Когда вы используете synchronized или статический метод или synchronized(class) или synchronized(static variable), он будет синхронизирован базой в классе

Ссылка

https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync. html

Надеюсь, что это поможет

Что такое ключевое слово synchronized?

Потоки передаются в основном путем совместного доступа к полям и полям ссылок объектов. Эта форма коммуникации чрезвычайно эффективна, но допускает два типа ошибок: помехи потоков и ошибки согласованности памяти . Инструмент, необходимый для предотвращения этих ошибок, - это синхронизация.

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

Когда синхронизируются методы?

Методы синхронизируются при добавлении synchronized в определение или объявление метода. Вы также можете синхронизировать определенный блок кода с помощью метода.

Что означает про грамматически и логически?

Это означает, что только один поток может получить доступ к критическому разделу , приобретя замок. Если этот поток не освободит эту блокировку, все остальные нити (ы) придется ждать, чтобы получить блокировку. У них нет доступа для входа в критический раздел без блокировки захвата.

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

Подробнее о документации java странице

Внутренние блокировки и синхронизация:

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

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

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

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

Выполнение синхронных методов имеет два эффекта :

Во-первых, невозможно, чтобы две вызовы синхронизированных методов на одном и том же объект для чередования.

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

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

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

Найдите другие альтернативы синхронизации в:

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

Я знаю, что вы уже получили свой ответ. Я пишу это, только чтобы помочь людям, которые имеют один и тот же вопрос, и ищут эту страницу для ответа. здесь объяснение из java documentation : Рассмотрим следующий код:

public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

, если count является экземпляром SynchronizedCounter, а затем синхронизация этих методов имеет два эффекта:

• Во-первых, невозможно, чтобы две вызовы синхронизированных методов на одном и том же объекте чередовали. Когда один поток выполняет синхронизированный метод для объекта, все другие потоки, которые вызывают синхронизированные методы для одного и того же объекта (приостановить выполнение) до тех пор, пока первый поток не будет выполнен с объектом.
• Во-вторых, когда синхронизированный метод выходит, он автоматически устанавливает связь между событиями и последующим вызовом синхронизированного метода для одного и того же объекта. Это гарантирует, что изменения состояния объекта будут видны для всех потоков.

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

В моем понимании синхронизировано в основном означает, что компилятор пишет monitor.enter и monitor.exit вокруг вашего метода. Как таковой он может быть потокобезопасным в зависимости от того, как он используется (я имею в виду, что вы можете написать объект с синхронизированными методами, который не является потокобезопасным в зависимости от того, что делает ваш класс).

Ключевое слово synchronized заставляет поток получать блокировку при вводе метода, так что только один поток может одновременно выполнить этот метод (для данного экземпляра объекта, если он не является статическим методом).

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

. Рассмотрим это:

 if (vector.isEmpty()){
     vector.add(data);
 }

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

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

Поскольку синхронизация на уровне метода является a) дорогой, когда она вам не нужна, и b) недостаточно, когда вы теперь требуется синхронизация с синхронизацией (ArrayList в случае Vector).

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

Отсутствие других ответов - один из важных аспектов: барьеры памяти . Синхронизация потоков в основном состоит из двух частей: сериализации и видимости. Я советую всем google «барьер памяти jvm», поскольку это нетривиальная и чрезвычайно важная тема (если вы изменяете общие данные, к которым обращаются несколько потоков). Сделав это, я советую посмотреть классы пакета java.util.concurrent, которые помогают избежать использования явной синхронизации, что в свою очередь помогает поддерживать простые и эффективные программы, возможно, даже предотвращая взаимоблокировки.

Одним из таких примеров является ConcurrentLinkedDeque . Вместе с шаблоном команды он позволяет создавать высокоэффективные рабочие потоки, набирая команды в параллельную очередь - не требуется явная синхронизация, невозможны взаимоблокировки, нет явного сна (), необходимо просто опросить очередь по вызову take ().

Короче: «синхронизация памяти» неявно неявно при запуске потока, конец потока, вы читаете изменчивую переменную, вы разблокируете монитор ( оставить синхронизированный блок / функцию) и т. д. Эта «синхронизация» влияет (в смысле «flushes») , все записывают до этого конкретного действия. В случае вышеупомянутого ConcurrentLinkedDeque документация «говорит»:

Эффекты согласованности памяти. Как и в случае с другими параллельными коллекциями, действия в потоке перед размещением объекта в действия ConcurrentLinkedDeque произошли до после доступа или удаления этого элемента из ConcurrentLinkedDeque в другом потоке.

Это неявное поведение является несколько пагубным аспектом, поскольку из-за этого большинство программистов Java без особого опыта просто возьмут много. И затем внезапно наткнуться на этот поток после того, как Java не делает то, что «предполагается» делать в производстве, где есть другая рабочая нагрузка, и довольно сложно проверить проблемы параллелизма.