Apakah wake up palsu di Jawa benar-benar terjadi?

Melihat berbagai pertanyaan terkait penguncian dan (hampir) selalu menemukan 'loop karena istilah wakeups palsu' ¹ Saya bertanya-tanya, adakah yang pernah mengalami wakeup semacam itu (misalnya, dengan asumsi lingkungan hardware / software yang layak)?

Saya tahu istilah 'palsu' berarti tidak ada alasan yang jelas tetapi apa yang bisa menjadi alasan untuk acara semacam itu?

( ¹ Catatan: Saya tidak mempertanyakan praktik perulangan.)

Sunting: Pertanyaan pembantu (bagi mereka yang suka contoh kode):

Jika saya memiliki program berikut, dan saya menjalankannya:

public class Spurious {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition cond = lock.newCondition();
        lock.lock();
        try {
            try {
                cond.await();
                System.out.println("Spurious wakeup!");
            } catch (InterruptedException ex) {
                System.out.println("Just a regular interrupt.");
            }
        } finally {
            lock.unlock();
        }
    }
}

Apa yang bisa saya lakukan untuk membangunkan ini awaitdengan palsu tanpa menunggu selamanya untuk acara acak?

Artikel Wikipedia tentang wake up palsu memiliki berita gembira ini:

The pthread_cond_wait()fungsi dalam Linux diimplementasikan dengan menggunakan futexsystem call. Setiap panggilan sistem pemblokiran di Linux kembali dengan tiba-tiba EINTRketika proses menerima sinyal. ... pthread_cond_wait()tidak dapat memulai kembali menunggu karena mungkin akan melewatkan bangun yang nyata dalam waktu sedikit di luar futexpanggilan sistem. Kondisi balapan ini hanya dapat dihindari oleh penelepon yang memeriksa invarian. Sinyal POSIX karenanya akan menghasilkan wake up yang palsu.

Rangkuman : Jika ada proses Linux yang diberi tanda, masing-masing utasnya akan menikmati bangun yang bagus dan panas .

Saya membelinya. Itu adalah pil yang lebih mudah untuk menelan daripada alasan "itu untuk kinerja" yang sering diberikan.

Saya memiliki sistem produksi yang menunjukkan perilaku ini. Utas menunggu sinyal bahwa ada pesan dalam antrian. Dalam periode sibuk, hingga 20% dari bangun adalah palsu (yaitu ketika bangun tidak ada dalam antrian). Utas ini adalah satu-satunya konsumen pesan. Ini berjalan pada kotak Linux SLES-10 8-prosesor dan dibangun dengan GCC 4.1.2. Pesan berasal dari sumber eksternal dan diproses secara tidak sinkron karena ada masalah jika sistem saya tidak membacanya dengan cukup cepat.

Untuk menjawab pertanyaan dalam titile - Ya! itu memang terjadi. Meskipun artikel Wiki menyebutkan banyak tentang wakeups palsu penjelasan yang bagus untuk hal yang sama yang saya temui adalah sebagai berikut -

Bayangkan saja ... seperti kode apa pun, penjadwal thread dapat mengalami pemadaman sementara karena sesuatu yang tidak normal terjadi pada perangkat keras / lunak yang mendasarinya. Tentu saja, kehati-hatian harus dilakukan agar hal ini terjadi sesedikit mungkin, tetapi karena tidak ada perangkat lunak yang kuat 100%, masuk akal untuk menganggap ini dapat terjadi dan berhati-hati pada pemulihan yang anggun jika seandainya scheduler mendeteksi ini (mis. dengan mengamati detak jantung yang hilang).

Sekarang, bagaimana scheduler dapat pulih, dengan mempertimbangkan bahwa selama pemadaman itu bisa kehilangan beberapa sinyal yang dimaksudkan untuk memberi tahu utas menunggu? Jika scheduler tidak melakukan apa pun, utas yang disebutkan "tidak beruntung" hanya akan hang, menunggu selamanya - untuk menghindari ini, scheduler hanya akan mengirim sinyal ke semua utas yang menunggu.

Ini membuatnya perlu untuk membuat "kontrak" bahwa utas menunggu dapat diberitahukan tanpa alasan. Tepatnya, akan ada alasan - pemadaman penjadwal - tetapi karena utas dirancang (untuk alasan yang baik) untuk tidak mengetahui detail implementasi internal penjadwal, alasan ini kemungkinan lebih baik untuk ditampilkan sebagai "palsu".

Saya membaca jawaban ini dari Sumber dan merasa cukup masuk akal. Baca juga

Kebangkitan palsu di Jawa dan cara menghindarinya .

PS: Tautan di atas adalah ke blog pribadi saya yang memiliki detail tambahan tentang bangun palsu.

Cameron Purdy menulis posting blog beberapa waktu lalu tentang terkena masalah wakeup palsu. Jadi ya, itu terjadi

Saya menduga itu dalam spesifikasi (karena kemungkinan) karena keterbatasan beberapa platform yang digunakan Java? meskipun saya mungkin salah!

Tambahkan saja ini. Ya itu terjadi dan saya menghabiskan tiga hari mencari penyebab masalah multi-threading pada mesin 24 core (JDK 6). 4 dari 10 eksekusi mengalami hal itu tanpa pola apa pun. Ini tidak pernah terjadi pada 2 inti atau 8 core.

Mempelajari beberapa materi online dan ini bukan masalah Java tetapi perilaku umum yang jarang tetapi diharapkan.

https://stackoverflow.com/a/1461956/14731 berisi penjelasan yang sangat baik tentang mengapa Anda perlu berjaga-jaga terhadap bangun palsu bahkan jika sistem operasi yang mendasarinya tidak memicu mereka. Sangat menarik untuk dicatat bahwa penjelasan ini berlaku di berbagai bahasa pemrograman, termasuk Java.

Menjawab pertanyaan OP

Apa yang bisa saya lakukan untuk membangunkan ini, menunggu dengan palsu tanpa menunggu selamanya untuk acara acak?

, tidak ada bangun palsu yang dapat membangunkan utas menunggu ini!

Terlepas dari apakah wakeups palsu dapat atau tidak bisa terjadi pada platform tertentu, dalam kasus potongan OP itu tidak mungkin untukCondition.await() kembali dan melihat garis "Wake up palsu!" dalam aliran output.

Kecuali Anda menggunakan Java Class Library yang sangat eksotis

Hal ini karena standar, OpenJDK 's ReentrantLock' s metode newCondition()pengembalian yang AbstractQueuedSynchronizer'implementasi s dari Conditioninterface, bersarang ConditionObject(by the way, itu adalah satu-satunya implementasi Conditionantarmuka di perpustakaan kelas ini), dan ConditionObject' s metode await()itu sendiri cek apakah kondisi tidak memegang dan tidak ada bangun palsu dapat memaksa metode ini untuk kembali secara keliru.

Omong-omong, Anda bisa memeriksanya sendiri karena cukup mudah untuk meniru bangun palsu setelah AbstractQueuedSynchronizerimplementasi berbasis-terlibat. AbstractQueuedSynchronizermenggunakan tingkat rendah LockSupport's parkdan unparkmetode, dan jika Anda menjalankan LockSupport.unparkpada thread menunggu diCondition , tindakan ini tidak dapat dibedakan dari wakeup palsu.

Sedikit refactoring cuplikan OP,

public class Spurious {

    private static class AwaitingThread extends Thread {

        @Override
        public void run() {
            Lock lock = new ReentrantLock();
            Condition cond = lock.newCondition();
            lock.lock();
            try {
                try {
                    cond.await();
                    System.out.println("Spurious wakeup!");
                } catch (InterruptedException ex) {
                    System.out.println("Just a regular interrupt.");
                }
            } finally {
                lock.unlock();
            }
        }
    }

    private static final int AMOUNT_OF_SPURIOUS_WAKEUPS = 10;

    public static void main(String[] args) throws InterruptedException {
        Thread awaitingThread = new AwaitingThread();
        awaitingThread.start();
        Thread.sleep(10000);
        for(int i =0 ; i < AMOUNT_OF_SPURIOUS_WAKEUPS; i++)
            LockSupport.unpark(awaitingThread);
        Thread.sleep(10000);
        if (awaitingThread.isAlive())
            System.out.println("Even after " + AMOUNT_OF_SPURIOUS_WAKEUPS + " \"spurious wakeups\" the Condition is stil awaiting");
        else
            System.out.println("You are using very unusual implementation of java.util.concurrent.locks.Condition");
    }
}

, dan tidak peduli seberapa keras utas yang tidak parkir (utama) akan mencoba untuk membangunkan utas yang menunggu, Condition.await()metode ini tidak akan pernah kembali dalam kasus ini.

Wakeups palsu pada Conditionmetode yang menunggu dibahas dalam javadoc Conditionantarmuka . Meskipun dikatakan bahwa,

ketika menunggu suatu Kondisi, bangun palsu diizinkan untuk terjadi

dan itu

direkomendasikan bahwa pemrogram aplikasi selalu berasumsi bahwa mereka dapat terjadi dan selalu menunggu dalam satu lingkaran.

tetapi kemudian menambahkan itu

Suatu implementasi gratis untuk menghilangkan kemungkinan wake up palsu

dan AbstractQueuedSynchronizerimplementasi Conditionantarmuka tidak persis seperti itu - menghilangkan segala kemungkinan wakeup palsu .

Ini tentu berlaku untuk ConditionObjectmetode lain yang menunggu.

Jadi kesimpulannya adalah:

kita harus selalu memanggil Condition.awaitloop dan memeriksa apakah kondisinya tidak berlaku, tetapi dengan standar, OpenJDK, Java Class Library tidak pernah bisa terjadi . Kecuali, sekali lagi, Anda menggunakan Java Class Library yang sangat tidak biasa (yang pasti sangat sangat tidak biasa, karena Java Class Library non-OpenJDK lain yang terkenal, yang saat ini hampir punah GNU Classpath dan Apache Harmony , tampaknya memiliki identik dengan implementasi standar Conditionantarmuka)