Cara menggunakan benang pengguna dan benang daemon di Jawa

1. Benang pengguna lalai

Kedua-dua benang dan kumpulan benang dalam bahasa Java lalai kepada urutan pengguna, jadi Benang pengguna adalah juga dipanggil benang biasa.

Ambil utas sebagai contoh Jika anda ingin menyemak sama ada utas ialah benang daemon, anda hanya perlu memanggil kaedah isDaemon() untuk membuat pertanyaan Jika nilai pertanyaan ialah false, ini bermakna bahawa ia bukan benang daemon, dan ia secara semula jadi milik utas Pengguna,

adalah seperti yang ditunjukkan dalam kod berikut:

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是子线程");
        }
    });
    System.out.println("子线程==守护线程：" + thread.isDaemon());
    System.out.println("主线程==守护线程：" + Thread.currentThread().isDaemon());
}

Hasil pelaksanaan daripada atur cara di atas ialah:

Seperti yang dapat dilihat daripada hasil di atas, secara lalai utas utama dan utas baharu yang dicipta adalah kedua-dua utas pengguna .

PS: Thread.currentThread() bermaksud untuk mendapatkan contoh utas yang melaksanakan kod semasa.

2. Ubah suai secara aktif kepada utas daemon

Benang Daemon (Benang Daemon) juga dipanggil utas latar belakang atau utas perkhidmatan Benang Daemon menyediakan utas pengguna , apabila semua utas pengguna dalam pelaksanaan program tamat, utas daemon juga akan tamat.

Peranan benang daemon adalah seperti "pelayan", dan peranan benang pengguna adalah seperti "pelanggan". (benang daemon) juga Tiada makna kewujudan, jadi apabila semua utas pengguna dalam program menamatkan pelaksanaan, tidak kira sama ada utas daemon masih berfungsi atau tidak, ia akan berakhir bersama-sama dengan utas pengguna, dan keseluruhan program juga akan tamat berlari.

Jadi bagaimana untuk menukar benang pengguna lalai kepada benang daemon?

Soalan ini harus dijawab dalam dua situasi Pertama, jika ia adalah benang, anda boleh terus mengubah suai benang pengguna kepada benang daemon dengan menetapkan kaedah setDaemon(true), dan jika ia adalah satu. thread pool, anda perlu lulus ThreadFactory Hanya jika setiap thread dalam thread pool ialah benang daemon, mari laksanakan secara berasingan.

2.1 Tetapkan benang sebagai benang daemon

Jika anda menggunakan benang, anda boleh menukar jenis benang kepada benang daemon melalui kaedah setDaemon(true), seperti yang ditunjukkan dalam kod berikut:

 public static void main(String[] args) throws InterruptedException {
     Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
             System.out.println("我是子线程");
         }
     });
     // 设置子线程为守护线程
     thread.setDaemon(true);
     System.out.println("子线程==守护线程：" + thread.isDaemon());
     System.out.println("主线程==守护线程：" + Thread.currentThread().isDaemon());
 }

Hasil pelaksanaan program di atas ialah:

2.2 Tetapkan kumpulan benang sebagai benang daemon

Untuk menetapkan benang Menetapkan kumpulan sebagai benang daemon agak menyusahkan Semua benang dalam kumpulan benang perlu ditetapkan sebagai benang daemon Pada masa ini, anda perlu menggunakan ThreadFactory untuk tentukan jenis utas setiap utas dalam kumpulan utas Kod pelaksanaan khusus adalah seperti berikut :

// 创建固定个数的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10, new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        // 设置线程为守护线程
        t.setDaemon(false);
        return t;
    }
});

Seperti yang ditunjukkan dalam gambar di bawah:

Seperti yang ditunjukkan dalam gambar di atas, dapat dilihat terdapat 10 orang penjaga dalam keseluruhan program The threads semuanya saya cipta. Beberapa tetapan lain untuk membuat kumpulan benang adalah serupa, dan semuanya ditetapkan secara seragam melalui ThreadFactory, jadi saya tidak akan menyenaraikannya satu demi satu di sini.

3. Benang Daemon VS benang pengguna

Melalui pembelajaran sebelumnya, kita boleh mencipta dua jenis benang yang berbeza. Seterusnya mari kita lihat menggunakan contoh kecil.

Seterusnya, kami mencipta utas, tetapkan utas ini sebagai utas pengguna dan benang daemon masing-masing, laksanakan gelung for dalam setiap utas, lakukan sebanyak 10 kali pencetakan maklumat dan tidur selama 100 milisaat selepas setiap cetakan , untuk memerhatikan hasil program yang dijalankan.

3.1 Benang pengguna

Benang yang baru dibuat ialah urutan pengguna secara lalai, jadi kami tidak perlu melakukan sebarang pemprosesan khas pada utas, cuma laksanakan gelung for (jumlah daripada 10 kali pencetakan maklumat, setiap Tidur selama 100 milisaat selepas cetakan), Kod pelaksanaan adalah seperti berikut:

/**
 * Author：Java中文社群
 */
public class DaemonExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    // 打印 i 信息
                    System.out.println("i:" + i);
                    try {
                        // 休眠 100 毫秒
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        // 启动线程
        thread.start();
    }
}

Hasil pelaksanaan program di atas adalah seperti berikut:

Daripada keputusan di atas, dapat dilihat bahawa proses tidak akan berakhir seperti biasa sehingga program telah melaksanakan 10 cetakan.

3.2 Benang Daemon

/**
 * Author：Java中文社群
 */
public class DaemonExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    // 打印 i 信息
                    System.out.println("i:" + i);
                    try {
                        // 休眠 100 毫秒
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        // 设置为守护线程
        thread.setDaemon(true);
        // 启动线程
        thread.start();
    }
}

Keputusan pelaksanaan program di atas adalah seperti berikut:

Seperti yang dapat dilihat daripada keputusan di atas, Apabila benang ditetapkan sebagai benang daemon, keseluruhan program tidak akan menunggu benang daemon for berkitar 10 kali sebelum dimatikan Sebaliknya, apabila benang utama tamat, benang daemon hanya melaksanakan kitaran sekali dan kemudian tamat Seperti yang dapat dilihat daripada ini Perbezaan antara benang daemon dan benang pengguna.

3.3 小结

守护线程是为用户线程服务的，当一个程序中的所有用户线程都执行完成之后程序就会结束运行，程序结束运行时不会管守护线程是否正在运行，由此我们可以看出守护线程在 Java 体系中权重是比较低的。

4.守护线程注意事项

守护线程的使用需要注意以下三个问题：

• 守护线程的设置 setDaemon(true) 必须要放在线程的 start() 之前，否则程序会报错。

• 在守护线程中创建的所有子线程都是守护线程。

• 使用 jojn() 方法会等待一个线程执行完，无论此线程是用户线程还是守护线程。

接下来我们分别演示一下，以上的注意事项。

4.1 setDaemon 执行顺序

当我们将 setDaemon(true) 设置在 start() 之后，如下代码所示：

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                // 打印 i 信息
                System.out.println("i:" + i + ",isDaemon:" +
                            Thread.currentThread().isDaemon());
                try {
                    // 休眠 100 毫秒
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    // 启动线程
    thread.start();
    // 设置为守护线程
    thread.setDaemon(true);
}

以上程序执行结果如下：

从上述结果可以看出，当我们将 setDaemon(true) 设置在 start() 之后，不但程序的执行会报错，而且设置的守护线程也不会生效。

4.2 守护线程的子线程

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {

                }
            });
            System.out.println("守护线程的子线程 thread2 isDaemon：" +
                              thread2.isDaemon());
        }
    });
    // 设置为守护线程
    thread.setDaemon(true);
    // 启动线程
    thread.start();

    Thread.sleep(1000);
}

以上程序执行结果如下：

从上述结果可以看出，守护线程中创建的子线程，默认情况下也属于守护线程。

4.3 join 与守护线程

通过 3.2 部分的内容我们可以看出，默认情况下程序结束并不会等待守护线程执行完，而当我们调用线程的等待方法 join() 时，执行的结果就会和 3.2 的结果有所不同，下面我们一起来看吧，

示例代码如下：

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                // 打印 i 信息
                System.out.println("i:" + i);
                try {
                    // 休眠 100 毫秒
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    // 设置为守护线程
    thread.setDaemon(true);
    // 启动线程
    thread.start();
    // 等待线程执行完
    thread.join();
    System.out.println("子线程==守护线程：" + thread.isDaemon());
    System.out.println("主线程==守护线程：" + Thread.currentThread().isDaemon());
}

以上程序执行结果如下：

通过上述结果我们可以看出，即使是守护线程，当程序中调用 join() 方法时，程序依然会等待守护线程执行完成之后再结束进程。

5.守护线程应用场景

守护线程的典型应用场景就是垃圾回收线程，当然还有一些场景也非常适合使用守护线程，比如服务器端的健康检测功能，对于一个服务器来说健康检测功能属于非核心非主流的服务业务，像这种为了主要业务服务的业务功能就非常合适使用守护线程，当程序中的主要业务都执行完成之后，服务业务也会跟随者一起销毁。

6.守护线程的执行优先级

首先来说，线程的类型（用户线程或守护线程）并不影响线程执行的优先级，如下代码所示，定义一个用户线程和守护线程，分别执行 10 万次循环，通过观察最后的打印结果来确认线程类型对程序执行优先级的影响。

public class DaemonExample {
    private static final int count = 100000;
    public static void main(String[] args) throws InterruptedException {
        // 定义任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < count; i++) {
                    System.out.println("执行线程：" + Thread.currentThread().getName());
                }
            }
        };
        // 创建守护线程 t1
        Thread t1 = new Thread(runnable, "t1");
        // 设置为守护线程
        t1.setDaemon(true);
        // 启动线程
        t1.start();
        // 创建用户线程 t2
        Thread t2 = new Thread(runnable, "t2");
        // 启动线程
        t2.start();
    }
}

以上程序执行结果如下：

通过上述结果可以看出，线程的类型不管是守护线程还是用户线程对程序执行的优先级是没有任何影响的，而当我们将 t2 的优先级调整为最大时，整个程序的运行结果就完全不同了，

如下代码所示：

public class DaemonExample {
    private static final int count = 100000;
    public static void main(String[] args) throws InterruptedException {
        // 定义任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < count; i++) {
                    System.out.println("执行线程：" + Thread.currentThread().getName());
                }
            }
        };
        // 创建守护线程 t1
        Thread t1 = new Thread(runnable, "t1");
        // 设置为守护线程
        t1.setDaemon(true);
        // 启动线程
        t1.start();
        // 创建用户线程 t2
        Thread t2 = new Thread(runnable, "t2");
        // 设置 t2 的优先级为最高
        t2.setPriority(Thread.MAX_PRIORITY);
        // 启动线程
        t2.start();
    }
}

以上程序执行结果如下： 

00000000 通过上述的结果可以看出，程序的类型和程序执行的优先级是没有任何关系，当新创建的线程默认的优先级都是 5 时，无论是守护线程还是用户线程，它们执行的优先级都是相同的，当将二者的优先级设置不同时，执行的结果也会随之改变（优先级设置的越高，最早被执行的概率也越大）。

Atas ialah kandungan terperinci Cara menggunakan benang pengguna dan benang daemon di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!