Bagaimana untuk membuat utas dilaksanakan dalam susunan yang ditentukan oleh mereka sendiri dalam Java

Cara membuat utas dilaksanakan dalam susunan yang anda tentukan

Dalam pembangunan berbilang benang harian, kadangkala kami mungkin mahu setiap utas dijalankan dalam susunan yang kami tentukan, dan bukannya membiarkan jadual CPU secara rawak , yang mungkin menyebabkan masalah yang tidak perlu dalam kerja pembangunan harian kita.

Memandangkan terdapat keperluan ini, tajuk artikel ini diperkenalkan untuk membolehkan urutan berjalan dalam susunan yang ditentukan oleh mereka sendiri.

Pelajar yang berminat boleh meneka kemungkinan keputusan kod berikut:

Mengikut pemahaman biasa, pelaksanaan kod di atas Urutannya hendaklah: t1 → t2 →

Gambar berikut menunjukkan kesan operasi:

Memahami Sertai

Sertai mungkin tidak sesuai untuk sesetengah orang pelajar Jika anda tidak biasa dengannya, saya tidak akan memperkenalkan secara terperinci apa itu Join di sini Pelajar yang mempunyai soalan boleh baidu dan google.

Di sini saya akan memperkenalkan secara langsung cara menggunakan join untuk mencapai kesan yang kita mahu lihat!

Di sini kami menggunakan kesan penyekatan Join untuk mencapai tujuan kami. Melihat hasil yang sedang berjalan dalam rajah di atas, kita dapat mengetahui bahawa program telah dilaksanakan dalam susunan yang kita tentukan dan memperoleh hasil yang kita inginkan.

Sebenarnya kita boleh fikir sedalam-dalamnya kenapa join boleh capai kesan yang kita nak? Seterusnya, mari kita lihat kod sumber:

Selepas memasukkan kod sumber gabungan, perkara pertama yang anda lihat ialah kaedah gabungan yang melepasi 0 parameter Pilih untuk terus masuk ke sini.

Pertama sekali, anda dapat melihat bahawa kaedah gabungan adalah selamat untuk benang Kedua, anda boleh melihatnya bersama-sama dengan gambar di atas apabila parameter masuk adalah 0. a wait(0) will be hit Method, pelajar yang berpengalaman sepatutnya dapat memahaminya secara langsung, di sini bermakna menunggu.

Tetapi perlu diingatkan bahawa penantian di sini pastinya bukan menunggu pemanggil, tetapi utas utama yang disekat t1, t2, dan t3 hanyalah sub-benang Apabila sub-benang selesai berjalan utas utama berakhir menunggu.

Berikut ialah demonstrasi cara join berfungsi, dan ia juga membuktikan bahawa join membolehkan kami mencapai hasil yang kami inginkan dalam program.

Selain menyertai membantu kami mengawal susunan benang dalam program, terdapat cara lain, contohnya, mari cuba menggunakan kumpulan benang.

Menggunakan kumpulan utas Executors

Executors ialah kelas operasi kumpulan thread di bawah pakej java.util.concurrent dalam JDK, yang boleh memberikan kami operasi kumpulan thread dengan mudah.

Di sini kami menggunakan kaedah newSingleThreadExecutor() dalam Executors untuk mencipta kumpulan benang satu-benang.

Seperti yang dapat dilihat dari rajah di atas, menggunakan kaedah newSingleThreadExecutor() masih boleh mencapai hasil yang kami jangkakan, prinsipnya sangat mudah ialah baris gilir berasaskan FIFO, dan Maksudnya, apabila kita menambah t1, t2, dan t3 pada baris gilir dalam urutan, hanya benang t1 sebenarnya dalam keadaan sedia, dan t2 dan t3 akan ditambah pada baris gilir. Apabila t1 selesai, pelaksanaan dalam baris gilir akan diteruskan.

Keutamaan thread dan urutan pelaksanaan

Apabila operator belajar, pembaca tahu bahawa terdapat keutamaan antara operator Memahami keutamaan operator adalah sangat baik untuk kesan pembangunan. Perkara yang sama berlaku untuk utas Setiap utas mempunyai keutamaan Mesin maya Java menentukan susunan pelaksanaan utas berdasarkan keutamaan utas, supaya berbilang utas boleh berkongsi sumber CPU tanpa konflik.

Gambaran Keseluruhan Keutamaan

Dalam bahasa Java, julat keutamaan urutan ialah 1~10, dan nilai mestilah antara 1~10, jika tidak, nilai lalai akan berlaku; keutamaan ialah 5. Benang dengan keutamaan yang lebih tinggi akan dilaksanakan dahulu, dan apabila pelaksanaan selesai, giliran benang dengan keutamaan yang lebih rendah untuk dilaksanakan. Sekiranya keutamaan adalah sama, ia akan dilaksanakan secara bergilir-gilir.

Anda boleh menggunakan kaedah setPriority() dalam kelas Thread untuk menetapkan keutamaan thread. Sintaksnya adalah seperti berikut:

public final void setPriority(int newPriority);

Jika anda ingin mendapatkan keutamaan urutan semasa, anda boleh memanggil kaedah getPriority() terus. Sintaksnya adalah seperti berikut:

public final int getPriority();

Menggunakan keutamaan

Setelah memahami secara ringkas keutamaan, mari gunakan contoh mudah untuk menunjukkan cara menggunakan keutamaan.

Contoh 1

Buat urutan masing-masing menggunakan kelas Thread dan antara muka Runnable, dan tetapkan keutamaan kepada mereka.

public class FirstThreadInput extends Thread
{
    public void run()
    {
        System.out.println("调用FirstThreadInput类的run()重写方法");    //输出字符串
        for(int i=0;i<5;i++)
        {
            System.out.println("FirstThreadInput线程中i="+i);    //输出信息
            try
            {
                Thread.sleep((int) Math.random()*100);    //线程休眠
            }
            catch(Exception e){}
        }
    }
}

(2) Cipta kelas SecondThreadInput yang melaksanakan antara muka Runnable dan melaksanakan kaedah run(). Kodnya adalah seperti berikut:

public class SecondThreadInput implements Runnable
{
    public void run()
    {
        System.out.println("调用SecondThreadInput类的run()重写方法");    //输出字符串
        for(int i=0;i<5;i++)
        {
            System.out.println("SecondThreadInput线程中i="+i);    //输出信息
            try
            {
                Thread.sleep((int) Math.random()*100);    //线程休眠
            }
            catch(Exception e){}
        }
    }
}

(3) 创建 TestThreadInput 测试类，分别使用 Thread 类的子类和 Runnable 接口的对象创建线程，然后调用 setPriority() 方法将这两个线程的优先级设置为 4，最后启动线程。代码如下：

public class TestThreadInput
{
    public static void main(String[] args)
    {
        FirstThreadInput fti=new FirstThreadInput();
        Thread sti=new Thread(new SecondThreadInput());
        fti.setPriority(4);
        sti.setPriority(4);
        fti.start();
        sti.start();
    }
}

(4) 运行上述代码，运行结果如下所示。

调用FirstThreadInput类的run()重写方法
调用SecondThreadInput类的run()重写方法
FirstThreadInput线程中i=0
SecondThreadInput线程中i=0
FirstThreadInput线程中i=1
FirstThreadInput线程中i=2
SecondThreadInput线程中i=1
FirstThreadInput线程中i=3
SecondThreadInput线程中i=2
FirstThreadInput线程中i=4
SecondThreadInput线程中i=3
SecondThreadInput线程中i=4

由于该例子将两个线程的优先级都设置为 4，因此它们交互占用 CPU ，宏观上处于并行运行状态。

重新更改 ThreadInput 类的代码、设置优先级。代码如下：

fti.setPriority(1);
sti.setPriority(10);

重新运行上述代码，如下所示。

调用FirstThreadInput类的run()重写方法
调用SecondThreadInput类的run()重写方法
FirstThreadInput线程中i=0
SecondThreadInput线程中i=0
SecondThreadInput线程中i=1
SecondThreadInput线程中i=2
SecondThreadInput线程中i=3
SecondThreadInput线程中i=4
FirstThreadInput线程中i=1
FirstThreadInput线程中i=2
FirstThreadInput线程中i=3
FirstThreadInput线程中i=4

Atas ialah kandungan terperinci Bagaimana untuk membuat utas dilaksanakan dalam susunan yang ditentukan oleh mereka sendiri dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!