Apakah empat fungsi benang yang biasa digunakan dalam Java?

1. wait()

Menyebabkan urutan semasa menunggu sehingga ia dibangkitkan, biasanya dengan diberitahu atau diganggu, atau sehingga masa masa nyata tertentu telah berlalu.

sendiri tergolong dalam kelas Objek Melihat kod sumber juga menunjukkan: Objek kelas awam {

Melihat kod sumber menunjukkan bahawa terdapat tiga kaedah terlampau bebanan Kod sumber terperinci adalah seperti berikut:

//第一个重载函数
public final void wait() throws InterruptedException {
        wait(0L);
    }
    
//第二个重载函数
public final native void wait(long timeoutMillis) throws InterruptedException;


//第三个重载函数
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeoutMillis value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
            timeoutMillis++;
        }

        wait(timeoutMillis);
    }

Kod panggilan sebenar yang khusus adalah seperti berikut:

Jika fungsi tunggu dilaksanakan, dalam masa 4 saat, kunci akan dilepaskan dan benang akan digantung. Jika anda bekerjasama dengan notify() dalam masa empat saat ini, anda boleh bangun dan mendapatkan kunci Jika anda tidak bangun, tunggu orang lain bersaing. Selepas 4 saat, kunci akan dilepaskan secara automatik secara lalai

Semasa utas semasa menunggu Thread.wait(), jika Thread tamat, ia boleh bangun secara automatik dan melepaskan kunci secara automatik

@Override
public void run() {
       synchronized (a) {
           a.wait(4000);      
       }
}

2. join()

Sertai ialah kaedah kelas Thread

Lihat kod sumbernya, kod sumber khusus adalah seperti berikut, tiga kaedah terlebih beban

//第一个重载函数
public final synchronized void join(final long millis)
    throws InterruptedException {
        if (millis > 0) {
            if (isAlive()) {
                final long startTime = System.nanoTime();
                long delay = millis;
                do {
                    wait(delay);
                } while (isAlive() && (delay = millis -
                        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
            }
        } else if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            throw new IllegalArgumentException("timeout value is negative");
        }
    }


//第二个重载函数
/*等待该线程死亡的时间最多为毫秒加纳秒。 如果两个参数都为0，则意味着永远等待。  
这个实现使用了This的循环。 等待电话以this.isAlive为条件。 当一个线程终止this。 
调用notifyAll方法。 建议应用程序不要使用wait、notify或notifyAll on Thread实例。  */
public final synchronized void join(long millis, int nanos)
throws InterruptedException {

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0 && millis < Long.MAX_VALUE) {
        millis++;
    }

    join(millis);
}


//第三个重载函数
/*等待线程死亡。  
此方法的调用与调用的行为完全相同  

InterruptedException—如果任何线程中断了当前线程。 当抛出此异常时，当前线程的中断状态将被清除。  */
public final void join() throws InterruptedException {
     join(0);
 }

Masa utama Logik parameter adalah seperti berikut:

• kurang daripada 0, pengecualian dilemparkan

• bersamaan dengan 0 , sertai (A), tentukan sama ada A wujud, dan laksanakannya hanya jika ia wujud. Urutan ini melaksanakan tunggu(0) dan menunggu urutan A selesai melaksanakan

• lebih besar daripada 0, sama seperti di atas, kecuali ia melaksanakan tunggu (millis panjang). boleh terus melakukan operasi

3 sleep()

Bandingkan fungsi tunggu sebelum ini

• tidur(kilang panjang. ) : Serahkan sumber CPU, tetapi tidak akan melepaskan sumber kunci.

• tunggu(): Serahkan sumber CPU dan kunci sumber.

Melihat kod sumber fungsi tidur, terdapat dua fungsi terlampau beban

kedua-duanya adalah fungsi kelas Benang

/*根据系统计时器和调度器的精度和准确性，
使当前执行的线程在指定的毫秒数内处于睡眠状态(暂时停止执行)。 
线程不会失去任何监视器的所有权。*/
public static native void sleep(long millis) throws InterruptedException;



/*导致当前执行的线程在指定的毫秒数加上指定的纳秒数
(取决于系统计时器和调度器的精度和准确性)内休眠(暂时停止执行)。 
线程不会失去任何监视器的所有权。  */
public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && millis < Long.MAX_VALUE) {
            millis++;
        }

        sleep(millis);
    }

4 . yield( )

Lihat kod sumber fungsi yield() Fungsi terlampau beban

ialah fungsi kelas Thread

memberi petunjuk kepada penjadual. benang semasa bersedia untuk melepaskan kawalan semasa penggunaan pemproses. Penjadual boleh mengabaikan gesaan ini.

Hasil ialah percubaan heuristik untuk meningkatkan kemajuan relatif antara urutan yang sebaliknya akan menggunakan CPU secara berlebihan. Penggunaannya hendaklah ditambah dengan analisis terperinci dan penanda aras untuk memastikan ia benar-benar mempunyai kesan yang dimaksudkan.

Menggunakan kaedah ini jarang sesuai. Ia mungkin digunakan untuk tujuan penyahpepijatan atau ujian di mana ia boleh membantu menghasilkan semula ralat disebabkan keadaan perlumbaan. Ia juga mungkin berguna apabila mereka bentuk binaan kawalan konkurensi seperti yang terdapat dalam pakej java.util.concurrent.locks.

public static native void yield();

Secara amnya, fungsi utama fungsi hasil ialah:

Serahkan penjadualan CPU dan jeda urutan, tetapi masa tidak dapat ditentukan oleh pengguna

Hanya boleh biarkan Ada peluang untuk melaksanakan dengan keutamaan yang sama

5 Ringkasan

tunggu jeda urutan, lepaskan CPU dan lepaskan kunci. (Kelas objek)

menyertai menjeda utas, dan hanya selepas melaksanakan utas itu boleh kembali ke utasnya sendiri. (Kelas benang)

tidur menjeda benang dan melepaskan CPU tanpa melepaskan kunci. (Kelas benang)

hasil menjeda urutan, tetapi ia tidak boleh ditentukan oleh pengguna Ia hanya boleh memberi keutamaan yang sama peluang untuk melaksanakan. (Kelas utas)

5.1 Perbezaan antara tunggu dan sertai

Selepas membaca kod sumber dan kod logik di atas, mari kita bincangkan tentang persamaan dan perbezaan antara kedua-duanya

Dalam umum

• fungsi tunggu: Letakkan utas semasa ke dalam keadaan menunggu, wait() akan digunakan bersama kaedah notify() dan notifyAll(). notify ialah fungsi wake-up

• fungsi sertai: tunggu sehingga thread ini tamat sebelum melaksanakan thread anda sendiri. Fungsi utamanya adalah untuk menyegerakkan, menukar pelaksanaan antara benang daripada "selari" kepada "bersiri". Apabila kaedah join() thread B dipanggil dalam thread A, proses pelaksanaan thread

berubah: thread A mesti menunggu thread B untuk menyelesaikan pelaksanaan sebelum dapat meneruskan pelaksanaan

Mata biasa:

• Jeda urutan semasa

• semuanya boleh dikejutkan oleh gangguan

Perbezaannya ialah:

区别	wait	join
类	Object类	Thread类
目的	线程间通信	排序，让其串行通过
同步	必须要synchronized	可以不用synchronized

5.2 Perbezaan antara tunggu dan tidur

tunggu(): Serahkan sumber CPU dan kunci sumber.

tidur(kilang panjang): Serahkan sumber CPU, tetapi tidak akan melepaskan sumber kunci.

Perbezaan terutamanya bergantung pada mekanisme pengendalian CPU:

Perbezaan terutamanya mengambil kira dua perkara: 1. Sama ada CPU terus melaksanakan, 2. Sama ada kunci dilepaskan.

Dalam analisis akhir:

tunggu, maklumkan, maklumkan semuanya adalah kaedah objek Objek dan digunakan bersama untuk mekanisme kunci, jadi kunci akan dilepaskan

dan tidur ialah Kelas Thread tiada kaitan dengan kunci Ia tidak akan melepaskan kunci

tetapi kedua-duanya akan menyerahkan sumber CPU

.

Atas ialah kandungan terperinci Apakah empat fungsi benang yang biasa digunakan dalam Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!