Rumah >Java >javaTutorial >Mekanisme penyegerakan dan penguncian antara muka dan kelas abstrak dalam Java
Mekanisme penyegerakan antara muka dan kelas abstrak dalam Java: Antara muka dan kelas abstrak tidak boleh dibuat seketika dan tidak boleh mempunyai kunci sendiri. Kaedah yang disegerakkan boleh diisytiharkan, yang serupa dengan kaedah biasa tetapi diubah suai menggunakan kata kunci yang disegerakkan. Apabila kaedah yang disegerakkan dipanggil, benang akan memperoleh kunci kaedah tersebut. Benang lain yang memanggil kaedah yang sama pada masa yang sama akan disekat sehingga kunci dilepaskan. Kes praktikal: Kelas sumber kongsi SharedResource mempunyai dua kaedah penyegerakan Dua utas mengakses sumber secara serentak Walau bagaimanapun, disebabkan penyegerakan kaedah, utas mesti menunggu akses kepada kunci sebelum mengubah suai nilai untuk memastikan ketepatan nilai dan mengelakkan konkurensi. masalah.
Mekanisme penyegerakan dan penguncian antara muka dan kelas abstrak dalam Java
Pengenalan
Penyegerakan ialah mekanisme untuk memastikan akses selamat kepada sumber dikongsi melalui berbilang rangkaian. Di Java, anda boleh menggunakan kunci untuk mencapai penyegerakan. Kunci ialah objek yang, apabila benang meminta kunci, menyekat benang lain daripada mengakses sumber sehingga kunci dilepaskan.
Penyegerakan dalam antara muka dan kelas abstrak
Antara muka dan kelas abstrak tidak boleh dibuat seketika, jadi mereka tidak boleh mempunyai kunci sendiri. Walau bagaimanapun, mereka boleh mengisytiharkan kaedah yang disegerakkan, yang hampir sama dengan kaedah biasa tetapi diubah suai menggunakan kata kunci synchronized
. synchronized
关键字修改。
public interface SynchronizedInterface { synchronized void synchronizedMethod(); } public abstract class SynchronizedAbstractClass { synchronized void synchronizedMethod(); }
当某个线程调用同步方法时,它将获取该方法的锁。如果另一个线程尝试同时调用同一个方法,它将被阻塞,直到该锁被释放。
实战案例
考虑一个共享资源类 SharedResource
,它具有两个同步方法:increment
和 decrement
。
public class SharedResource { private int value = 0; public synchronized void increment() { value++; } public synchronized void decrement() { value--; } }
现在,我们有两个线程 Thread1
和 Thread2
,它们并发地访问 SharedResource
。
public class Thread1 implements Runnable { private SharedResource sharedResource; @Override public void run() { for (int i = 0; i < 100000; i++) { sharedResource.increment(); } } } public class Thread2 implements Runnable { private SharedResource sharedResource; @Override public void run() { for (int i = 0; i < 100000; i++) { sharedResource.decrement(); } } } public class Main { public static void main(String[] args) { SharedResource sharedResource = new SharedResource(); Thread1 thread1 = new Thread1(); Thread2 thread2 = new Thread2(); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final value: " + sharedResource.value); } }
在这个案例中,两个线程并行地调用 increment
和 decrement
方法,但由于这些方法是同步的,因此每个线程在修改 value
之前都必须等待对锁的访问。这确保了 value
rrreee
SharedResource
, yang mempunyai dua kaedah penyegerakan: Thread1
dan Thread2
, yang mengakses SharedResource
secara serentak. 🎜rrreee🎜Dalam kes ini, dua utas memanggil kaedah kenaikan
dan decree
secara selari, tetapi memandangkan kaedah ini disegerakkan, setiap urutan mengubah suai nilai kod> mesti menunggu akses kepada kunci sebelum. Ini memastikan bahawa nilai <code>value
sentiasa betul dan tiada isu konkurensi timbul. 🎜Atas ialah kandungan terperinci Mekanisme penyegerakan dan penguncian antara muka dan kelas abstrak dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!