ใครช่วยบอกฉันทีว่าเธรด daemon อยู่ใน Java อะไร?

ตอบ

เธรด daemon เป็นเธรดที่ไม่ได้ป้องกันไม่ให้ JVM ออกเมื่อโปรแกรมเสร็จสิ้น แต่เธรดยังคงทำงานอยู่ ตัวอย่างสำหรับเธรด daemon คือการรวบรวมขยะ

คุณสามารถใช้setDaemon(boolean)เมธอดเพื่อเปลี่ยนThreadคุณสมบัติของ daemon ก่อนที่เธรดจะเริ่มต้น

อีกสองสามจุด (อ้างอิง: Java Concurrency in Practice )

  • เมื่อสร้างเธรดใหม่ จะสืบทอดสถานะ daemon ของพาเรนต์
  • เมื่อเธรดที่ไม่ใช่ daemon ทั้งหมดเสร็จสิ้น JVM จะหยุดทำงาน และเธรด daemonที่เหลือจะถูกละทิ้ง :

    • ในที่สุดบล็อกจะไม่ถูกดำเนินการ ,
    • สแต็คไม่คลี่คลาย - JVM เพิ่งออก

    ด้วยเหตุนี้จึงควรใช้เธรด daemon อย่างจำกัด และเป็นอันตรายที่จะใช้สำหรับงานที่อาจดำเนินการ I/O ทุกประเภท

คำตอบข้างต้นทั้งหมดเป็นสิ่งที่ดี นี่เป็นข้อมูลโค้ดสั้นๆ ง่ายๆ เพื่อแสดงความแตกต่าง ลองกับแต่ละค่าของ true และ false ในsetDaemon.

public class DaemonTest {
    
    public static void main(String[] args) {
        new WorkerThread().start();

        try {
            Thread.sleep(7500);
        } catch (InterruptedException e) {
            // handle here exception
        }

        System.out.println("Main Thread ending") ;
    }

}

class WorkerThread extends Thread {
    
    public WorkerThread() {
        // When false, (i.e. when it's a non daemon thread),
        // the WorkerThread continues to run.
        // When true, (i.e. when it's a daemon thread),
        // the WorkerThread terminates when the main 
        // thread or/and user defined thread(non daemon) terminates.
        setDaemon(true); 
    }
    
    public void run() {
        int count = 0;

        while (true) {
            System.out.println("Hello from Worker "+count++);

            try {
                sleep(5000);
            } catch (InterruptedException e) {
                // handle exception here
            }
        }
    }
}

ตามเนื้อผ้ากระบวนการ daemon ใน UNIX คือกระบวนการที่ทำงานอย่างต่อเนื่องในพื้นหลัง เหมือนกับบริการใน Windows

daemon thread ใน Java เป็นเธรดที่ไม่ได้ป้องกันไม่ให้ JVM ออก โดยเฉพาะ JVM จะออกเมื่อเหลือเพียงเธรด daemon เท่านั้น คุณสร้างมันขึ้นมาโดยเรียกใช้setDaemon()เมธอดในThread.

ได้อ่านของหัวข้อภูต

เธรด Daemon เปรียบเสมือนผู้ให้บริการสำหรับเธรดหรืออ็อบเจ็กต์อื่นที่ทำงานอยู่ในกระบวนการเดียวกับเธรด daemon เธรด Daemon ใช้สำหรับงานสนับสนุนเบื้องหลัง และจำเป็นเฉพาะในขณะที่เธรดปกติกำลังดำเนินการอยู่ หากเธรดปกติไม่ทำงาน และเธรดที่เหลือเป็นเธรด daemon ล่ามจะออก

ตัวอย่างเช่น เบราว์เซอร์ HotJava ใช้เธรด daemon สูงสุดสี่เธรดที่ชื่อ "Image Fetcher" เพื่อดึงรูปภาพจากระบบไฟล์หรือเครือข่ายสำหรับเธรดที่ต้องการ

โดยทั่วไปแล้วเธรด Daemon จะใช้เพื่อดำเนินการบริการสำหรับแอปพลิเคชัน/แอปเพล็ตของคุณ (เช่น การโหลด "fiddley bits") ความแตกต่างหลักระหว่างเธรดผู้ใช้และเธรด daemon คือ JVM จะปิดโปรแกรมเมื่อเธรดผู้ใช้ทั้งหมดสิ้นสุดเท่านั้น เธรด Daemon ถูกยกเลิกโดย JVM เมื่อไม่มีเธรดของผู้ใช้ที่ทำงานอยู่อีกต่อไป รวมถึงเธรดหลักของการดำเนินการ

setDaemon(จริง/เท็จ) ? เมธอดนี้ใช้เพื่อระบุว่าเธรดเป็นเธรด daemon

isDaemon() บูลีนสาธารณะ ? วิธีนี้ใช้เพื่อกำหนดว่าเธรดนั้นเป็น daemon thread หรือไม่

เช่น:

public class DaemonThread extends Thread {
    public void run() {
        System.out.println("Entering run method");

        try {
            System.out.println("In run Method: currentThread() is" + Thread.currentThread());

            while (true) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException x) {}

                System.out.println("In run method: woke up again");
            }
        } finally {
            System.out.println("Leaving run Method");
        }
    }
    public static void main(String[] args) {
        System.out.println("Entering main Method");

        DaemonThread t = new DaemonThread();
        t.setDaemon(true);
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException x) {}

        System.out.println("Leaving main method");
    }

}

เอาท์พุท:

C:\java\thread>javac DaemonThread.java

C:\java\thread>java DaemonThread
Entering main Method
Entering run method
In run Method: currentThread() isThread[Thread-0,5,main]
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
Leaving main method

C:\j2se6\thread>

daemon: d (isk) a (nd) e (xecution) mon (itor) หรือจากde (vice) mon (itor)

คำจำกัดความของ Daemon (คอมพิวเตอร์):

A background process that handles requests for services such as print spooling and file transfers, and is dormant when not required.

—— ที่มา: ภาษาอังกฤษโดย Oxford Dictionaries

เธรด Daemon ใน Java คืออะไร

  • เธรด Daemon สามารถปิดได้ตลอดเวลาระหว่างโฟลว์ เธรดผู้ใช้ที่ไม่ใช่ Daemon เช่น ดำเนินการอย่างสมบูรณ์
  • เธรด Daemon เป็นเธรดที่รันเป็นระยะ ๆ ในพื้นหลังตราบใดที่เธรดอื่นที่ไม่ใช่ daemon ทำงานอยู่
  • เมื่อเธรดที่ไม่ใช่ daemon ทั้งหมดเสร็จสมบูรณ์ เธรด daemon จะยุติโดยอัตโนมัติ
  • เธรด Daemon เป็นผู้ให้บริการสำหรับเธรดผู้ใช้ที่ทำงานในกระบวนการเดียวกัน
  • JVM ไม่สนใจว่าเธรด daemon จะต้องดำเนินการให้เสร็จสิ้นเมื่ออยู่ในสถานะกำลังรัน แม้แต่ในท้ายที่สุดก็ยังไม่สามารถดำเนินการบล็อกได้ JVM ให้ความสำคัญกับเธรดที่ไม่ใช่ daemon ที่เราสร้างขึ้น
  • เธรด Daemon ทำหน้าที่เป็นบริการใน Windows
  • JVM หยุดเธรด daemon เมื่อเธรดผู้ใช้ทั้งหมด (ตรงกันข้ามกับเธรด daemon) ถูกยกเลิก ดังนั้นเธรด daemon จึงสามารถนำไปใช้ได้ ตัวอย่างเช่น ฟังก์ชันการมอนิเตอร์ เนื่องจาก JVM หยุดเธรดทันทีที่เธรดของผู้ใช้ทั้งหมดหยุดทำงาน

ด้ายภูตเป็นหัวข้อที่ถือว่าทำงานบางอย่างในพื้นหลังเช่นการจัดการแสดงหรือ chronjobs ต่างๆที่สามารถอยู่ในใบสมัคร

เมื่อโปรแกรมของคุณมีเธรด daemonเหลืออยู่เท่านั้น โปรแกรมจะออกจากการทำงาน นั่นเป็นเพราะว่าโดยปกติเธรดเหล่านี้จะทำงานร่วมกับเธรดปกติและให้การจัดการพื้นหลังของเหตุการณ์

คุณสามารถระบุได้ว่า a Threadเป็นdaemonหนึ่งโดยใช้setDaemonเมธอด โดยปกติจะไม่ออก ไม่ถูกขัดจังหวะ .. จะหยุดเมื่อแอปพลิเคชันหยุด

ความเข้าใจผิดประการหนึ่งที่ฉันอยากจะชี้แจง:

  • สมมติว่าถ้าสร้างเธรด daemon (พูด B) ภายในเธรดผู้ใช้ (พูด A); จากนั้นการสิ้นสุดเธรดผู้ใช้/เธรดหลัก (A) จะไม่สิ้นสุดเธรด daemon/เธรดย่อย (B) ที่สร้างขึ้น ให้เธรดผู้ใช้เป็นเธรดเดียวที่กำลังทำงานอยู่
  • ดังนั้นจึงไม่มีความสัมพันธ์แบบ parent-child ในการสิ้นสุดเธรด เธรด daemon ทั้งหมด (ไม่ว่าจะสร้างขึ้นที่ใด) จะสิ้นสุดเมื่อไม่มีเธรดผู้ใช้ที่ใช้งานจริง และทำให้ JVM ยุติการทำงาน
  • แม้สิ่งนี้จะเป็นจริงสำหรับทั้งคู่ (พาเรนต์/ชายด์) ก็เป็นเธรด daemon
  • หากเธรดย่อยสร้างจากเธรด daemon นั่นก็เป็นเธรด daemon ด้วย ไม่จำเป็นต้องมีการตั้งค่าแฟล็กเธรด daemon ที่ชัดเจน ในทำนองเดียวกัน หากเธรดย่อยที่สร้างจากเธรดผู้ใช้ นั่นก็เป็นเธรดผู้ใช้เช่นกัน หากคุณต้องการเปลี่ยน คุณต้องตั้งค่าแฟล็ก daemon อย่างชัดเจนก่อนที่จะเริ่มเธรดชายด์นั้น

เธรด Daemon และเธรดผู้ใช้ โดยทั่วไป เธรดทั้งหมดที่สร้างโดยโปรแกรมเมอร์คือเธรดของผู้ใช้ (เว้นแต่คุณจะระบุว่าเป็น daemon หรือเธรดพาเรนต์ของคุณเป็นเธรด daemon) เธรดผู้ใช้โดยทั่วไปมีไว้เพื่อเรียกใช้โค้ดโปรแกรมของเรา JVM จะไม่ยุติเว้นแต่ว่าเธรดผู้ใช้ทั้งหมดจะสิ้นสุด

Java มีเธรดชนิดพิเศษที่เรียกว่าdaemon thread

  • ลำดับความสำคัญต่ำมาก
  • ดำเนินการเฉพาะเมื่อไม่มีเธรดอื่นของโปรแกรมเดียวกันกำลังทำงานอยู่
  • JVM สิ้นสุดโปรแกรมที่จบเธรดเหล่านี้ เมื่อเธรด daemon เป็นเธรดเดียวที่ทำงานในโปรแกรม

เธรด daemon ใช้ทำอะไร

ปกติใช้เป็นผู้ให้บริการสำหรับเธรดปกติ มักจะมีการวนซ้ำไม่สิ้นสุดที่รอการร้องขอบริการหรือดำเนินการงานของเธรด พวกเขาไม่สามารถทำงานที่สำคัญได้ (เพราะเราไม่รู้ว่าพวกมันจะมีเวลาของ CPU เมื่อไหร่ และสามารถจบได้ตลอดเวลาหากไม่มีเธรดอื่นทำงานอยู่ )

ตัวอย่างทั่วไปของชนิดของหัวข้อเหล่านี้เป็นคนเก็บขยะ Java

ยังมีอีก...

  • คุณเรียกใช้setDaemon()เมธอดก่อนเรียกใช้start()เมธอดเท่านั้น เมื่อเธรดทำงาน คุณจะไม่สามารถแก้ไขสถานะ daemon ได้
  • ใช้isDaemon()วิธีตรวจสอบว่าเธรดเป็นเธรด daemon หรือเธรดผู้ใช้หรือไม่

เธรด Daemon เป็นเหมือนผู้ช่วย เธรดที่ไม่ใช่ Daemon เป็นเหมือนนักแสดงหน้า ผู้ช่วยช่วยให้นักแสดงทำงานให้เสร็จลุล่วง เมื่องานเสร็จสิ้น นักแสดงก็ไม่ต้องการความช่วยเหลืออีกต่อไป เนื่องจากไม่ต้องการความช่วยเหลือ ผู้ช่วยจึงออกจากสถานที่ ดังนั้นเมื่องานของเธรดที่ไม่ใช่ Daemon สิ้นสุดลง เธรด Daemon จะถูกย้ายออกไป

นี่คือตัวอย่างเพื่อทดสอบพฤติกรรมของเธรด daemon ในกรณีที่ออก jvm เนื่องจากไม่มีเธรดของผู้ใช้

โปรดสังเกตบรรทัดสุดท้ายที่สองในผลลัพธ์ด้านล่าง เมื่อเธรดหลักออก เธรด daemon ก็หยุดทำงานและไม่ได้พิมพ์คำสั่งสุดท้ายที่ดำเนินการ 9คำสั่งภายในบล็อกในที่สุด ซึ่งหมายความว่าทรัพยากร i/o ใดๆ ที่ปิดภายในบล็อกสุดท้ายของเธรด daemon จะไม่ถูกปิดหาก JVM ออกเนื่องจากการไม่มีเธรดของผู้ใช้

public class DeamonTreadExample {

public static void main(String[] args) throws InterruptedException {

    Thread t = new Thread(() -> {
        int count = 0;
        while (true) {
            count++;
            try {
                System.out.println("inside try"+ count);
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                System.out.println("finally executed"+ count);
            }
        }
    });
    t.setDaemon(true);
    t.start();

    Thread.currentThread().sleep(10000);
    System.out.println("main thread exited");
  }
}

เอาท์พุต

inside try1
finally executed1
inside try2
finally executed2
inside try3
finally executed3
inside try4
finally executed4
inside try5
finally executed5
inside try6
finally executed6
inside try7
finally executed7
inside try8
finally executed8
inside try9
finally executed9
inside try10
main thread exited

ใน Java Daemon Threads เป็นหนึ่งในประเภทของเธรดที่ไม่ได้ป้องกันไม่ให้ Java Virtual Machine (JVM) ออกจากการทำงาน จุดประสงค์หลักของเธรด daemon คือเพื่อรันงานเบื้องหลังโดยเฉพาะในกรณีที่มีงานประจำหรืองานประจำบางอย่าง เมื่อออก JVM เธรด daemon ก็ตายเช่นกัน

โดยการตั้งค่า a thread.setDaemon(true)เธรดจะกลายเป็นเธรด daemon อย่างไรก็ตาม คุณสามารถตั้งค่านี้ได้ก่อนที่เธรดจะเริ่มต้นเท่านั้น

เธรด Daemon เหมือนกับเธรดปกติ ยกเว้นว่า JVM จะปิดตัวลงเมื่อเธรดอื่นที่ไม่ใช่ daemon นั้นไม่มีอยู่เท่านั้น โดยทั่วไปแล้วเธรด Daemon จะใช้เพื่อดำเนินการบริการสำหรับแอปพลิเคชันของคุณ

เธรด Daemon ใน Java เป็นเธรดที่ทำงานในพื้นหลังและส่วนใหญ่สร้างโดย JVM สำหรับการทำงานเบื้องหลัง เช่น การรวบรวมขยะ และงานดูแลบ้านอื่นๆ

ข้อสังเกต :

  1. เธรดใด ๆ ที่สร้างโดยเธรดหลักซึ่งรันเมธอดหลักใน Java โดยค่าเริ่มต้นไม่ใช่ daemon เนื่องจากเธรดสืบทอดธรรมชาติของ daemon จากเธรดที่สร้างมันขึ้นมา เช่น เธรดพาเรนต์ และเนื่องจากเธรดหลักเป็นเธรดที่ไม่ใช่ daemon เธรดอื่นใดที่สร้างขึ้นจากเธรดนั้นจะ ยังคงเป็น non-daemon จนกว่าจะสร้าง daemon อย่างชัดเจนโดยการเรียก setDaemon(true)

  2. Thread.setDaemon(true) สร้าง Thread daemon แต่สามารถเรียกได้ก่อนที่จะเริ่ม Thread ใน Java เท่านั้น มันจะส่ง IllegalThreadStateException หากเธรดที่เกี่ยวข้องเริ่มต้นและทำงานอยู่แล้ว

ความแตกต่างระหว่างเธรด Daemon และ Non Daemon ใน Java:

1) JVM ไม่รอให้เธรด daemon เสร็จสิ้นก่อนที่จะมีอยู่

2) Daemon Thread ได้รับการปฏิบัติที่แตกต่างจาก User Thread เมื่อ JVM ยุติลง ท้ายที่สุดแล้วจะไม่เรียกบล็อก สแต็คจะไม่ถูกคลาย และ JVM เพิ่งจะออกจากระบบ

เธรด Daemon เป็นไปตามที่ทุกคนอธิบาย จะไม่ จำกัด JVM ให้ออก ดังนั้นโดยพื้นฐานแล้วมันเป็นเธรดที่มีความสุขสำหรับแอปพลิเคชันจากมุมมองทางออก

ต้องการเพิ่มเธรด daemon ที่สามารถใช้ได้เมื่อบอกว่าฉันกำลังจัดเตรียม API เช่น การพุชข้อมูลไปยังเซิร์ฟเวอร์บุคคลที่สาม / หรือ JMS ฉันอาจต้องรวบรวมข้อมูลที่ระดับ JVM ของไคลเอ็นต์แล้วส่งไปยัง JMS ในเธรดแยกต่างหาก ฉันสามารถสร้างเธรดนี้เป็นเธรด daemon หากนี่ไม่ใช่ข้อมูลบังคับที่จะพุชไปยังเซิร์ฟเวอร์ ข้อมูลประเภทนี้เหมือนกับการพุชบันทึก / การรวม

ขอแสดงความนับถือ Manish

เธรด Daemon เป็นเหมือนกระบวนการของ daemon ซึ่งรับผิดชอบในการจัดการทรัพยากร เธรด daemon ถูกสร้างขึ้นโดย Java VM เพื่อให้บริการเธรดของผู้ใช้ ตัวอย่างการอัพเดทระบบสำหรับยูนิกซ์,ยูนิกซ์เป็นกระบวนการภูต เธรดย่อยของ daemon เป็นเธรด daemon เสมอ ดังนั้นโดยค่าเริ่มต้น daemon จะเป็น false คุณสามารถตรวจสอบเธรดในฐานะ daemon หรือผู้ใช้โดยใช้เมธอด "isDaemon()" ดังนั้น daemon thread หรือกระบวนการ daemon จึงมีหน้าที่ในการจัดการทรัพยากรโดยทั่วไป ตัวอย่างเช่น เมื่อคุณเริ่มต้น jvm จะมีตัวรวบรวมขยะที่ทำงานอยู่ซึ่งเป็นเธรด daemon ที่มีลำดับความสำคัญคือ 1 ซึ่งต่ำที่สุด ซึ่งกำลังจัดการหน่วยความจำ jvm ยังมีชีวิตอยู่ตราบใดที่เธรดผู้ใช้ยังมีชีวิตอยู่ คุณไม่สามารถฆ่า daemon thread.jvm มีหน้าที่ฆ่าเธรด daemon

สำหรับฉัน daemon thread มันเหมือนกับ housekeeper สำหรับเธรดของผู้ใช้ หากเธรดผู้ใช้ทั้งหมดเสร็จสิ้น เธรด daemon จะไม่มีงานและถูกฆ่าโดย JVM ผมอธิบายไว้ในวิดีโอ YouTube

มาคุยกันในโค้ดพร้อมตัวอย่างการทำงานเท่านั้น ฉันชอบคำตอบของ russ ด้านบน แต่เพื่อขจัดข้อสงสัยที่ฉันมี ฉันได้ปรับปรุงมันเล็กน้อย ฉันรันสองครั้ง ครั้งหนึ่งโดยตั้งค่าเธรดของผู้ปฏิบัติงานเป็น deamon true (เธรด deamon) และอีกครั้งตั้งค่าเป็น false (เธรดผู้ใช้) เป็นการยืนยันว่าเธรด deamon สิ้นสุดลงเมื่อเธรดหลักสิ้นสุดลง

public class DeamonThreadTest {

public static void main(String[] args) {

    new WorkerThread(false).start();    //set it to true and false and run twice.

    try {
        Thread.sleep(7500);
    } catch (InterruptedException e) {
        // handle here exception
    }

    System.out.println("Main Thread ending");
    }
   }

   class WorkerThread extends Thread {

    boolean isDeamon;

    public WorkerThread(boolean isDeamon) {
        // When false, (i.e. when it's a user thread),
        // the Worker thread continues to run.
        // When true, (i.e. when it's a daemon thread),
        // the Worker thread terminates when the main
        // thread terminates.
        this.isDeamon = isDeamon;
        setDaemon(isDeamon);
    }

    public void run() {
        System.out.println("I am a " + (isDeamon ? "Deamon Thread" : "User Thread (none-deamon)"));

        int counter = 0;

        while (counter < 10) {
            counter++;
            System.out.println("\tworking from Worker thread " + counter++);

            try {
                sleep(5000);
            } catch (InterruptedException e) {
                // handle exception here
            }
        }
        System.out.println("\tWorker thread ends. ");
    }
}



result when setDeamon(true)
=====================================
I am a Deamon Thread
    working from Worker thread 0
    working from Worker thread 1
Main Thread ending

Process finished with exit code 0


result when setDeamon(false)
=====================================
I am a User Thread (none-deamon)
    working from Worker thread 0
    working from Worker thread 1
Main Thread ending
    working from Worker thread 2
    working from Worker thread 3
    working from Worker thread 4
    working from Worker thread 5
    working from Worker thread 6
    working from Worker thread 7
    working from Worker thread 8
    working from Worker thread 9
    Worker thread ends. 

Process finished with exit code 0

เธรด Daemon โดยทั่วไปเรียกว่าเธรด "ผู้ให้บริการ" เธรดเหล่านี้ไม่ควรใช้เพื่อรันโค้ดโปรแกรม แต่ควรใช้โค้ดระบบ เธรดเหล่านี้ทำงานขนานกับโค้ดของคุณ แต่ JVM สามารถฆ่าได้ทุกเมื่อ เมื่อ JVM ไม่พบเธรดของผู้ใช้ ระบบจะหยุดการทำงานและเธรด daemon ทั้งหมดจะสิ้นสุดทันที เราสามารถตั้งค่าเธรดที่ไม่ใช่ daemon เป็น daemon โดยใช้:

setDaemon(true)

เธรด Daemon เป็นเธรดที่ทำงานในพื้นหลังตราบใดที่เธรดอื่นที่ไม่ใช่ daemon ของกระบวนการยังคงทำงานอยู่ ดังนั้น เมื่อเธรดที่ไม่ใช่ daemon ทั้งหมดเสร็จสมบูรณ์ เธรด daemon จะถูกยกเลิก ตัวอย่างสำหรับเธรดที่ไม่ใช่ daemon คือเธรดที่รัน Main เธรดถูกสร้างเป็น daemon โดยการเรียกsetDaemon()เมธอดก่อนที่จะเริ่มเธรด

สำหรับการอ้างอิงเพิ่มเติม: เธรด Daemon ใน Java

มีคำตอบมากมายอยู่แล้ว อย่างไรก็ตาม บางทีฉันอาจจะอธิบายให้กระจ่างกว่านี้หน่อย เพราะตอนที่ฉันอ่านเกี่ยวกับDaemon Threadsในตอนแรก ฉันมีความรู้สึกว่า ฉันเข้าใจดี อย่างไรก็ตาม หลังจากเล่นและดีบั๊กเล็กน้อย ฉันก็สังเกตเห็นพฤติกรรมแปลก ๆ (สำหรับฉัน)

ฉันถูกสอนว่า:

If I want the thread to die right after the main thread orderly finishes its execution, I should set it as Diamond.

สิ่งที่ฉันพยายาม:

  • ฉันสร้างสองเธรดจากMain Threadและฉันตั้งหนึ่งในนั้นเป็น a diamond;
  • หลังจากที่เสร็จสิ้นการดำเนินการที่เป็นระเบียบเรียบร้อยของMain Thread, ไม่มีกระทู้ที่สร้างขึ้นใหม่ออกมาแต่ผมคาดว่าDaemonด้ายควรได้รับการออก;
  • ฉันท่องไปในบล็อกและบทความมากมาย และคำจำกัดความที่ดีที่สุดและชัดเจนที่สุดที่ฉันเคยพบมา มาจากหนังสือJava Concurrency In Practiceซึ่งระบุไว้อย่างชัดเจนว่า:

7.4.2 เธรดภูต

Sometimes you want to create a thread that performs some helper function but you don’t want the existence of this thread to prevent the JVM from shutting down. This is what daemon threads are for. Threads are divided into two types: normal threads and daemon threads. When the JVM starts up, all the threads it creates (such as garbage collector and other housekeeping threads) are daemon threads, except the main thread. When a new thread is created, it inherits the daemon status of the thread that created it, so by default any threads created by the main thread are also normal threads. Normal threads and daemon threads differ only in what happens when they exit. When a thread exits, the JVM performs an inventory of running threads, and if the only threads that are left are daemon threads, it initiates an orderly shutdown. When the JVM halts, any remaining daemon threads are abandoned— finally blocks are not executed, stacks are not unwound—the JVM just exits. Daemon threads should be used sparingly—few processing activities can be safely abandoned at any time with no cleanup. In particular, it is dangerous to use daemon threads for tasks that might perform any sort of I/O. Daemon threads are best saved for “housekeeping” tasks, such as a background thread that periodically removes expired entries from an in-memory cache.

JVM จะทำงานให้สำเร็จเมื่อการประมวลผลเธรดที่ไม่ใช่ daemon ครั้งสุดท้ายเสร็จสิ้น โดยค่าเริ่มต้น JVM จะสร้างด้ายเป็น nondaemon แต่เราสามารถทำให้กระทู้เป็น daemon setDaemon(true)ด้วยความช่วยเหลือของวิธีการ ตัวอย่างที่ดีของเธรด Daemon คือเธรด GC ซึ่งจะทำงานของเขาให้เสร็จทันทีที่เธรด nondaemon ทั้งหมดเสร็จสิ้น

  • เธรด Daemon คือเธรดที่ให้บริการทั่วไปสำหรับเธรดผู้ใช้ (ตัวอย่าง: บริการล้าง - ตัวรวบรวมขยะ)
  • เธรด Daemon ทำงานตลอดเวลาจนกระทั่ง JVM . ฆ่า
  • Daemon Threads ได้รับการปฏิบัติแตกต่างจาก User Thread เมื่อ JVM ยุติ ท้ายที่สุดบล็อกจะไม่ถูกเรียก JVM เพียงแค่ออกจาก
  • JVM จะไม่ยุติเว้นแต่ว่าเธรดผู้ใช้ทั้งหมดจะยุติลง JVM สิ้นสุดลงหากเธรดผู้ใช้ทั้งหมดตาย
  • JVM ไม่รอให้เธรด daemon ใด ๆ เสร็จสิ้นก่อนที่มีอยู่และสุดท้ายจะไม่ถูกเรียก
  • หากเธรดผู้ใช้ทั้งหมดตาย JVM จะฆ่าเธรด daemon ทั้งหมดก่อนที่จะหยุด
  • เมื่อเธรดผู้ใช้ทั้งหมดสิ้นสุดลง เธรด daemon สามารถยุติได้และโปรแกรมหลักจะยุติลง
  • ต้องเรียกใช้เมธอด setDaemon() ก่อนเรียกเมธอด start() ของเธรด
  • เมื่อเธรดเริ่มดำเนินการสถานะ daemon จะไม่สามารถเปลี่ยนแปลงได้
  • หากต้องการตรวจสอบว่าเธรดเป็นเธรด daemon หรือไม่ ให้ใช้เมธอด accessor isDaemon()

เธรด Java daemon

[กระบวนการภูต]

การใช้จาวาuser threadและdaemon treadแนวคิด

กระแส JVM

1. If there are no `user treads` JVM starts terminating the program
2. JVM terminates all `daemon threads` automatically without waiting when they are done
3. JVM is shutdown

อย่างที่คุณเห็นdaemon treadเป็นเธรดบริการสำหรับuser treads.

  • daemon tread เป็นเธรดที่มีลำดับความสำคัญต่ำ
  • เธรดสืบทอดคุณสมบัติจากเธรดหลัก หากต้องการตั้งค่าภายนอกคุณสามารถใช้setDaemon()วิธีการก่อนเริ่มหรือตรวจสอบผ่านisDaemon()

เธรด Daemon ตายเมื่อเธรดผู้สร้างออก

เธรดที่ไม่ใช่ daemon (ค่าเริ่มต้น) สามารถอยู่ได้นานกว่าเธรดหลัก

if ( threadShouldDieOnApplicationEnd ) {
    thread.setDaemon ( true );
}
thread.start();