Kata Kunci Meruap dalam java

Meruap dalam java berfungsi seperti, jika kita mahu objek kita diakses oleh berbilang benang secara serentak, kita boleh menggunakan kata kunci ini. Kata kunci ini ialah satu lagi cara untuk menjadikan kelas, kod, kaedah thread-selamat yang bermakna berbilang rangkaian boleh mengakses sumber yang sama tanpa sebarang masalah. Kami bermaksud melanggar kata kunci menunjukkan bahawa kami boleh mengatakan berbilang urutan akan memanipulasi nilai pembolehubah itu secara serentak.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Apabila kita menggunakan kata kunci yang tidak menentu dalam java?

Jika anda ingin memastikan benang kod anda selamat, anda boleh menggunakan kata kunci yang melanggar. Juga, ia menyediakan penyegerakan; dalam kes ini, ia adalah pilihan yang baik.

Sebarang pembolehubah yang kami isytiharkan menggunakan kata kunci ini tidak akan pergi ke cache; semua operasi yang kami lakukan, seperti membaca dan menulis, akan pergi ke ingatan utama.

class DemoSharedObject
{
static int sharedresources = 10;
}

Di bawah satu kes yang membawa kepada ketidakkonsistenan data:

Kami mempunyai satu kelas bernama DemoSharedObject, mari kita anggap bahawa berbilang urutan berfungsi pada kelas ini dan akan mengubah suai nilai ahli kelas. Jadi, jika kita mempunyai berbilang utas yang berjalan pada pemproses yang berbeza, setiap utas ini mempunyai sumber salinan setempatnya sendiri. Jadi jika beberapa utas mengubah suai nilai sumber biasa, nilainya tidak akan dipantulkan ke dalam ingatan utama dengan cepat. Tetapi dalam kes ini, urutan kami yang lain tidak mengetahui tentang nilai semasa untuk sumber yang dikongsi, jadi ini akan membawa kepada isu ketidakkonsistenan data.

Di java, kami mempunyai dua perkara penyataan penyegerakan dan kaedah penyegerakan.

Kaedah penyegerakan

Dalam kes ini, kami hanya menambah kata kunci yang disegerakkan pada tandatangan kaedah.

sintaks:

public synchronized return_type method_name(){}

Contoh:

public class Demosynchronized {
private int c = 0;
public synchronized void method1() {
c++;
}
public synchronized void method2() {
c--;
}
public synchronized int method3() {
return c;
}
}

Dalam contoh di atas, kami tidak melakukan apa-apa selain hanya menambah dan mengurangkan pembilang, tetapi kami perlu memperkenalkan kata kunci yang disegerakkan dengan kaedah supaya tidak akan berlaku ketidakkonsistenan data dan semua urutan akan menerima nilai yang dikemas kini.

Jadi apabila utas pertama sedang melakukan pemprosesannya pada kaedah1(), semua utas lain akan mendapat sekatan (gantung); tiada benang lain boleh mengakses objek yang sama sehingga benang yang berfungsi telah memperoleh kunci objek. Beginilah cara mereka mengelakkan ketidakkonsistenan data.

Selain itu, kini terdapat lebih banyak perkara yang apabila benang menyelesaikan operasinya pada kaedah1(), iaitu pelaksanaan lengkap kaedah, jadi ia mewujudkan hubungan dengan benang lain supaya perubahan dalam nilai atau keadaan objek kelihatan ke benang lain juga.

Pernyataan disegerakkan

sintaks:

synchronized(){}

Contoh:

public void demo(String namestr) {
synchronized(this) {
lastName = namestr;
count++;
}
list.add(namestr);
}

Dalam contoh di atas, kami mempunyai blok disegerakkan yang akan mengurus data untuk kami. Seperti namestr akan disegerakkan oleh kaedah demo(). Ini bermakna data yang ingin kita segerakkan; kita hanya perlu meletakkannya di dalam blok ini sahaja.

jadi apabila kita mempunyai dua utas iaitu menulis dan membaca pada objek yang sama bermakna kita mempunyai berbilang utas yang mengakses objek yang sama untuk tujuan membaca dan menulis maka kita harus menggunakan kata kunci yang melanggar kerana ia tidak memberikan kita jaminan menyekat utas melainkan dan sehingga utas lain berhenti di sana pelaksanaan, jadi dalam kes ini, kita harus pergi untuk penyegerakan kerana ia memberikan kita beberapa lagi ciri berbanding kata kunci yang melanggar seperti :

ia boleh digunakan dengan kaedah serta blok pernyataan yang bermakna kita tidak perlu menyegerakkan keseluruhan kaedah; kita boleh menulis kod kita di dalam blok juga, yang kita mahu segerakkan.

Apabila kita membaca atau menulis nilai pembolehubah yang tidak menentu, mereka terus membaca atau menulis nilai ke memori utama, yang bukan amalan yang baik, dan ini juga mahal jika dibandingkan dengan cache. Jadi fikir sebelum anda menggunakan kata kunci yang tidak menentu; ia akan memberi kesan secara langsung kepada prestasi anda.

Andaikan kita mempunyai berbilang utas yang tidak bergantung pada respons satu sama lain yang bermaksud membaca dan menulis adalah bebas antara satu sama lain untuk menggunakan kata kunci yang tidak menentu dalam kes ini. Tetapi kami mempunyai satu lagi kes juga di mana ia tidak sesuai untuk menggunakan kata kunci yang tidak menentu yang dijelaskan di bawah :

Suppose thread has generated the first value of the volatile variable, and this current value will be used further to generate the new volatile variable values; in this case, this volatile keyword is not a good fit to generate the correct result; this condition will lead to a race condition were all thread going to read the same value but generate the new value for them and write the value to main memory and override each other values, so this will leads to the wrong result, or we can say data inconsistency issue, so here volatile keyword is not good enough to avoid this case we have to move to synchronization where we have to types to make our code synchronized, i.e. synchronized method and synchronized statement.

Example

Code:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TvvApplication {
private static final Logger LOGGER = LoggerFactory.getLogger(TvvApplication.class);
private static final Object aclock = new Object();
private static final Object aclock1 = new Object();
private static volatile int MY_INT = 0;
public static void main(String[] args) {
System.out.println("without block");
System.out.println("with block calling static method :: ");
testBlock();
}
static void testBlock1() {
synchronized (aclock1) {
MY_INT = MY_INT + 1;
System.out.println( Thread.currentThread().getName() +"new lock we create and printing voilatile value using block for block one:: "+ MY_INT);
}
}
static void testBlock() {
synchronized (aclock) {
MY_INT = MY_INT + 1;
System.out.println( Thread.currentThread().getName() +"new lock we create and printing voilatile value using block for block two:: "+ MY_INT);
}
}
}

Output :

<img src="https://img.php.cn/upload/article/000/000/000/172500598784733.png" alt="Kata Kunci Meruap dalam java" >

Conclusion

So this can provide thread safety when data does not depend on each other; if data depends, we should go for synchronization.

Atas ialah kandungan terperinci Kata Kunci Meruap dalam java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!