Pag-synchronize ng thread, pag-lock ng object at pag-lock ng klase

Ang pag-synchronize ay tumutukoy sa multithreading. Ang isang naka-synchronize na bloke ng code ay maaari lamang isagawa ng isang thread sa isang pagkakataon. Sinusuportahan ng Java ang maraming mga thread para sa pagpapatupad. Ito ay maaaring magresulta sa dalawa o higit pang mga thread sa pag-access sa parehong field o bagay. Ang pag-synchronize ay isang proseso na nagbibigay-daan sa lahat ng parallel na thread sa isang programa na tumakbo nang sabay-sabay. Iniiwasan ng pag-synchronize ang mga error sa pagkakapare-pareho ng memory na dulot ng hindi pare-parehong pag-access sa nakabahaging memorya. Kapag ang isang pamamaraan ay idineklara bilang naka-synchronize, ang thread ay may hawak na monitor para sa bagay na ang pamamaraan ay isinasagawa. Kung ang isa pang thread ay nagsasagawa ng isang naka-synchronize na paraan, ang iyong thread ay haharangin hanggang sa ilabas ng kabilang thread ang monitor. Nakamit ang synchronization sa Java gamit ang isang nakalaan na salita synchronized. Magagamit mo ito sa iyong mga klase sa pamamagitan ng pagtukoy ng mga naka-synchronize na pamamaraan o block. Hindi mo magagamit synchronizedang mga variable o attribute sa isang kahulugan ng klase.

Pag-lock sa antas ng bagay

Ito ay isang mekanismo para sa pag-synchronize ng isang non-static na pamamaraan o non-static na bloke ng code upang ang isang thread lamang ang maaaring magsagawa ng isang partikular na bloke o pamamaraan sa isang partikular na halimbawa ng isang klase. Dapat itong gawin sa tuwing kailangan mong gawing ligtas ang thread ng data sa antas ng halimbawa. Halimbawa:

public class DemoClass{
    public synchronized void demoMethod(){}
}

o

public class DemoClass{
    public void demoMethod(){
        synchronized (this)        {
            //other thread safe code
        }
    }
}

o

public class DemoClass{
    private final Object lock = new Object();
    public void demoMethod(){
        synchronized (lock)        {
            //other thread safe code
        }
    }
}

Pag-lock sa antas ng klase

Pinipigilan ang maraming mga thread mula sa pagpasok ng isang naka-synchronize na bloke sa panahon ng pagpapatupad sa alinman sa mga magagamit na pagkakataon ng klase. Nangangahulugan ito na kung mayroong 100 instance ng klase sa panahon ng pagpapatupad ng isang program DemoClass, isang thread lang sa oras na iyon ang makakapag-execute demoMethod()sa alinman sa mga kaso, at iba-block ang lahat ng iba pang mga kaso para sa iba pang mga thread. Ito ay kinakailangan kapag kailangan mong gawing ligtas ang static na data thread.

public class DemoClass{
    public synchronized static void demoMethod(){}
}

o

public class DemoClass{
    public void demoMethod(){
        synchronized (DemoClass.class)        {
            //other thread safe code
        }
    }
}

o

public class DemoClass
{
    private final static Object lock = new Object();
    public void demoMethod(){
        synchronized (lock)        {
            //other thread safe code
        }
    }
}

Ilang Mahalagang Tala

1. Tinitiyak ng pag-synchronize sa Java na walang dalawang thread ang makakapagsagawa ng isang naka-synchronize na paraan nang sabay o kahanay.


2. synchronizedmaaari lamang gamitin sa mga pamamaraan at mga bloke ng code. Ang mga pamamaraan o block na ito ay maaaring static o non-static.


3. Sa tuwing ang anumang thread ay pumapasok sa isang naka-synchronize na pamamaraan o na-block ito ay nakakakuha ng isang lock at sa tuwing ang isang thread ay lalabas sa isang naka-synchronize na paraan o na-block ang JVM ay naglalabas ng lock. Ang lock ay inilabas kahit na ang thread ay umalis sa naka-synchronize na paraan pagkatapos makumpleto dahil sa anumang mga error o exception.


4. synchronizedsa Java , nangangahulugan ito na kung ang isang naka-synchronize na paraan ay tumawag ng isa pang naka-synchronize na paraan na nangangailangan ng parehong lock, ang kasalukuyang thread na may hawak ng lock ay maaaring pumasok sa paraang iyon nang hindi nakukuha ang lock.


5. Синхронизация в Java будет бросать NullPointerException если an object используемый в синхронизированном блоке null. Например, в вышеприведенном примере codeа, если замок инициализируется How null, синхронизированный (lock) бросит NullPointerException.


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


7. Вполне возможно, что и статический и не статический синхронизированные методы могут работать одновременно or параллельно, потому что они захватывают замок на другой an object.


8. В соответствии со спецификацией языка вы не можете использовать synchronized в конструкторе это приведет к ошибке компиляции.


9. Не синхронизируйте по не финальному (no final) полю, потому что link, на не финальное поле может измениться в любое время, а затем другой поток может получить синхронизацию на разных an objectх и уже не будет ниHowой синхронизации вообще. Лучше всего использовать класс String, который уже неизменяемый и финальный.

Удачи в обучении!! Оригинал: Object level lock vs Class level lock in Java