Dalam pemrograman multi-utas Java, volatile sering ditemukan. Terkadang kata kunci ini sering bingung dengan sinkronisasi atau kunci. Analisis spesifiknya adalah sebagai berikut:
Dalam lingkungan multi-threaded, akan ada masalah visibilitas variabel anggota: setiap utas di Java memiliki ruang memori tumpukan utas, yang menyimpan informasi variabel utas saat berjalan. Ketika utas mengakses nilai variabel tertentu, pertama -tama akan menemukan memori tumpukan objek atau konten spesifik dari tumpukan (tipe data asli) berdasarkan alamat variabel, dan kemudian menyimpan salinan nilai yang sama di tumpukan utas utas ini. Kemudian, semua operasi pada variabel ini tidak ada hubungannya dengan konten variabel di tumpukan sebelum utas keluar. Ini beroperasi pada salinan di tumpukan utas. Setelah operasi selesai, hasil operasi akan ditulis kembali ke memori utama. Jika ada dua utas A dan B, dan rekannya mengoperasikan variabel x tertentu; A menambahkan 1 ke x, kemudian salinan yang diperoleh B mungkin merupakan hasil dari x plus 1, atau x; Untuk memastikan bahwa variabel data terbaru dalam memori diperlukan untuk menambahkan kata kunci yang mudah menguap, jadi setiap kali Anda beroperasi pada X, Anda akan memeriksa apakah nilai variabel dalam tumpukan utas sama dengan nilai variabel dalam memori, dan jika berbeda, itu akan dimuat lagi.
misalnya:
ThreadSee kelas publik {// utas T1 akan melakukan operasi yang sesuai berdasarkan nilai flag, dan utas utama akan mengubah nilai t1 public static void main (string [] args) melempar InterruptedException {threadtest th = new threadTest (); Utas T1 = utas baru (TH); t1.start (); Thread.sleep (1000); th.changeflag (); Thread.sleep (2000); System.out.println (th.getFlag ()); }} class ThreadTest mengimplementasikan runnable {// Ketika utas mengakses variabel, itu akan memuatnya ke tumpukan utas yang sesuai. Setiap operasi, ia harus mendapatkan data terbaru dalam memori sobat boolean volatile privat; @Override public void run () {int i = 0; while (! StopFlag) {i ++; System.out.println ("=="+thread.currentThread (). GetName ()); } System.out.println ("Thread Finish:"+i); } public void changeFlag () {this.stopflag = true; System.out.println (thread.currentThread (). GetName ()+"*********"); } public boolean getFlag () {return stopflag; }} Jika kode di atas dihapus, itu akan terus dieksekusi dalam loop dead.
Tapi volatile tidak dapat menjamin sinkronisasi yang aman-utas
misalnya:
Public Class ThreadSave mengimplementasikan runnable {static ThreadSave sync = new threadSave (); statis volatile int j = 0; // lock lock = reentrantlock baru (); public void inscane () {// lock.lock (); untuk (int i = 0; i <10000000; i ++) {j ++; } // lock.unlock (); } @Override public void run () {inscane (); } public static void main (string [] args) melempar interruptedException {thread t1 = utas baru (sinc); Utas T2 = utas baru (sinkronisasi); t1.start (); t2.start (); t1.join (); t2.join (); System.out.println (j); }} Hasil eksekusi menurut kode di atas tidak diharapkan menjadi tahun 200.000,
Karena untuk variabel yang dimodifikasi oleh volatile, mesin virtual JVM hanya memastikan bahwa nilai yang dimuat dari memori utama ke memori kerja utas adalah yang terbaru.
Misalnya, jika Thread 1 dan Thread 2 melakukan tumpukan utas dan operasi membaca dan memuat utama, dan menemukan bahwa nilai jumlah dalam memori utama adalah 5, maka nilai terbaru akan dimuat. Setelah Thread 1 Heap Count dimodifikasi, itu akan ditulis ke dalam memori utama, dan variabel hitungan dalam memori utama akan menjadi 6;
Karena Thread 2 telah melakukan operasi baca dan beban, setelah melakukan operasi, nilai variabel dari jumlah memori utama juga akan diperbarui ke 6;
Hal ini menyebabkan konkurensi terjadi setelah dua utas dimodifikasi dengan kata kunci yang mudah menguap dalam waktu.
Singkatnya:
Volatile hanya akan memastikan bahwa utas melakukan tindakan yang memeriksa apakah nilai variabel tumpukan utas saat ini sama dengan nilai data dalam memori utama, itu saja. Kunci atau disinkronkan akan memastikan bahwa hanya satu utas yang memasukkan metode pada saat tertentu, sehingga memastikan keamanan utasnya.
Jadi jika beberapa utas memodifikasi variabel volatil, maka tidak ada makna logis yang sebenarnya. Jika utas memodifikasi nilai variabel utas lain yang bergantung pada pengubah, itu akan berguna saat ini.
Di atas adalah semua tentang artikel ini, saya harap ini akan membantu untuk pembelajaran semua orang.