Keadaan kaum berlaku apabila pelbagai benang mengakses data bersama, yang membawa kepada ketidakkonsistenan; Betulkan dengan disegerakkan, atomicinteger, atau reentrantlock. 2. Deadlock timbul apabila benang menunggu selama -lamanya untuk kunci masing -masing; Mencegah dengan pesanan kunci yang konsisten, menggunakan trylock dengan tamat masa, dan pemantauan dengan JStack. 3. Isu penglihatan berlaku disebabkan oleh caching CPU atau menyusun semula; Selesaikan dengan kata kunci yang tidak menentu, walaupun operasi kompaun masih memerlukan penyegerakan. 4. Masalah Lines termasuk kelaparan, di mana benang ditolak sumber, dikurangkan oleh kunci yang adil, dan livelock, di mana benang tidak membuat kemajuan, diselesaikan dengan backoff rawak. 5. Menyalahgunakan tunggu ()/memberitahu () menyebabkan isyarat atau pengecualian yang tidak dijawab; Sentiasa gunakan tunggu () dalam beberapa gelung dalam blok yang disegerakkan. 6. Lebih suka alat konvensional peringkat tinggi seperti executorservice, concurrenthashmap, menyekat, dan countdownlatch untuk mengurangkan risiko kesilapan. Untuk mengelakkan isu-isu konvensyen, meminimumkan keadaan yang boleh dimakan bersama dan bergantung kepada utiliti yang selamat dan objek yang tidak berubah apabila mungkin.

Konvensyen di Java membolehkan pelbagai benang berjalan secara serentak, meningkatkan prestasi dan respons-terutamanya dalam aplikasi sisi pelayan. Tetapi dengan kuasa besar datang kerumitan yang besar. Apabila tidak ditangani dengan betul, kesesuaian dapat memperkenalkan isu-isu halus, keras-debug. Berikut adalah masalah yang paling biasa dan bagaimana menyelesaikannya dengan berkesan.

1. Keadaan perlumbaan dan ketidakkonsistenan data

Keadaan perlumbaan berlaku apabila pelbagai benang mengakses data yang dikongsi bersama secara serentak, dan sekurang -kurangnya salah satu daripada mereka mengubahnya, yang membawa kepada hasil yang tidak dapat diramalkan.

Contoh:

 kaunter kelas awam {
    kiraan int swasta = 0;
    Peningkatan void awam () {Count; }
    public int getCount () {return count; }
}

increment() dari pelbagai benang boleh menyebabkan kemas kini yang hilang kerana count tidak atom -ia melibatkan bacaan, mengubah, dan menulis langkah.

Penyelesaian:

• Gunakan kata kunci synchronized :

   Peningkatan void yang disegerakkan awam () {count; }

  Ini hanya memastikan satu benang dapat melaksanakan kaedah pada satu masa.

• Gunakan java.util.concurrent.atomic Classes:

   kiraan atomicInteger swasta = AtomicInteger baru (0);
  public void kenaikan () {count.incrementAndget (); }

  Kelas-kelas atom menyediakan operasi selamat-selamat tanpa kunci.

• Gunakan kunci eksplisit ( ReentrantLock ):

   REENTRANTLOCK LOCK Final Private = New ReentRantLock ();
  kenaikan void awam () {
      lock.lock ();
      Cuba {
          kiraan;
      } akhirnya {
          lock.unlock ();
      }
  }

  Menawarkan lebih banyak kawalan daripada synchronized , termasuk dasar percubaan dan keadilan.

2. Deadlock

Deadlock berlaku apabila dua atau lebih benang disekat selama -lamanya, masing -masing menunggu sumber yang dipegang oleh yang lain.

Contoh: Thread A memegang kunci 1 dan menunggu kunci 2.
Thread B memegang kunci 2 dan menunggu kunci 1 → kebuntuan.

Cara mengelakkan:

• Sentiasa memperoleh kunci dalam susunan yang konsisten: menguatkuasakan pesanan global (misalnya, selalu memperoleh kunci 1 sebelum kunci 2).

• Gunakan masa tamat semasa memperoleh kunci:

   jika (lock.trylock (1000, timeUnit.milliseconds)) {
      Cuba {
          // seksyen kritikal
      } akhirnya {
          lock.unlock ();
      }
  } else {
      // mengendalikan masa
  }

• Gunakan alat seperti jstack untuk mengesan kebuntuan semasa pembangunan.

3. Gangguan Thread dan Masalah Penglihatan

Walaupun operasi muncul atom, pengoptimuman JVM dan CPU (seperti caching dalam daftar CPU atau arahan penyusunan semula) boleh menyebabkan satu benang tidak melihat perubahan yang dibuat oleh yang lain.

Contoh:

 Boolean Private Running = True;
public void run () {
    Semasa (berlari) {
        // buat kerja
    }
}

Satu set benang running = false , tetapi benang lain mungkin tidak pernah melihat kemas kini kerana caching.

Penyelesaian: Gunakan kata kunci volatile :

 Boolean yang tidak menentu peribadi berjalan = benar;

volatile memastikan:

• Menulis kepada pembolehubah dapat dilihat dengan segera ke benang lain.
• Menghalang penyusunan semula pengkompil/CPU tertentu di sekitar pembolehubah.

Untuk tindakan kompaun (seperti bacaan-modifikasi-menulis), volatile sahaja tidak cukup-kombine dengan penyegerakan atau kelas atom.

4. Masalah Lines: Livelock dan kelaparan

• Kelaparan: benang secara berterusan ditolak akses kepada sumber. Sebagai contoh, benang keutamaan rendah mungkin tidak akan mendapat masa CPU.

  • Betulkan: Gunakan dasar penguncian yang adil ( new ReentrantLock(true) ), elakkan menunggu gelung tanpa had tanpa menghasilkan.

• Livelock: Threads aktif tetapi tidak dapat membuat kemajuan (contohnya, dua benang berulang kali bertindak balas terhadap tindakan masing -masing).

  • Betulkan: Memperkenalkan strategi rawak atau backoff. Sebagai contoh, cuba semula dengan kelewatan rawak.

notify() wait() notifyAll()

Menggunakan wait() tanpa gelung atau di luar blok synchronized boleh menyebabkan isyarat IllegalMonitorStateException atau yang tidak dijawab.

Corak yang betul:

 disegerakkan (kunci) {
    Semasa (ConditionNotMet) {
        lock.wait (); // Melepaskan kunci dan menunggu
    }
    // teruskan ketika keadaan dipenuhi
}

Sentiasa:

• Panggil wait() di dalam gelung while (tidak if ) untuk mengkaji semula keadaan selepas bangun.
• Pastikan kunci diadakan sebelum menelefon wait() atau notify() .

Sebagai alternatif, gunakan utiliti konkurensi peringkat tinggi.

6. Lebih suka utiliti konkurrensi peringkat tinggi

Daripada menguruskan benang dan mengunci secara manual, gunakan pakej java.util.concurrent :

• ExecutorService untuk Pengurusan Thread:

   ExecutOrservice Executor = executors.NewFixedThreadPool (4);
  executor.submit (() -> dowork ());

• ConcurrentHashMap , CopyOnWriteArrayList untuk Koleksi Safe Thread.

• BlockingQueue corak pengguna-pengguna:

   BlockingQueue <Task> queue = new LinkedBlockingQueue <> ();

• CountDownLatch , CyclicBarrier , Semaphore untuk Penyelarasan.

Ini adalah pertempuran yang diuji, cekap, dan mengurangkan peluang kesilapan.

---

Pada asasnya, sementara Java memberikan anda alat yang kuat untuk kesesuaian, kunci adalah untuk meminimumkan keadaan mutable bersama dan bersandar pada utiliti yang terbukti dan bukannya menggulung penyegerakan anda sendiri. Kebanyakan isu berpunca daripada mengandaikan keselamatan benang apabila ia tidak dijamin-jadi apabila ragu-ragu, periksa dokumen atau gunakan objek yang tidak berubah dan kelas selamat.

Atas ialah kandungan terperinci Menyelesaikan masalah keserasian biasa di java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!