Co to jest wątek demona w Javie?

Czy ktoś może mi powiedzieć, jakie wątki demonów są w Javie ?

Wątek demona jest wątkiem, który nie uniemożliwia wyjścia maszyny JVM po zakończeniu programu, ale wątek nadal działa. Przykładem wątku demona jest odśmiecanie.

Możesz użyć tej setDaemon(boolean)metody, aby zmienić Threadwłaściwości demona przed uruchomieniem wątku.

Jeszcze kilka punktów (odniesienie: Java Concurrency in Practice )

• Po utworzeniu nowego wątku dziedziczy status demona jego elementu nadrzędnego.

• Gdy wszystkie wątki niebędące demonami zakończą się, maszyna JVM zatrzymuje się, a wszelkie pozostałe wątki demonów są porzucane :

  • wreszcie bloki nie są wykonywane ,
  • stosy nie są rozwijane - JVM właśnie wychodzi.
    
    

  Z tego powodu wątki demonów powinny być używane oszczędnie, a ich używanie do zadań, które mogą wykonywać dowolne operacje wejścia / wyjścia, jest niebezpieczne.

Wszystkie powyższe odpowiedzi są dobre. Oto prosty krótki fragment kodu, który ilustruje różnicę. Wypróbuj z każdą wartością true i false w 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 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.
        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
            }
        }
    }
}

Tradycyjnie procesami demonów w systemie UNIX były procesy działające w tle, podobnie jak usługi w systemie Windows.

Wątek demona w Javie to taki, który nie uniemożliwia wyjścia JVM. W szczególności JVM zakończy działanie, gdy pozostaną tylko wątki demona. Tworzysz go, wywołując setDaemon()metodę Thread.

Przeczytaj wątki Daemon .

Wątki demona są jak dostawcy usług dla innych wątków lub obiektów działających w tym samym procesie co wątek demona. Wątki demona są używane do zadań wspierających w tle i są potrzebne tylko podczas wykonywania normalnych wątków. Jeśli normalne wątki nie są uruchomione, a pozostałe wątki są wątkami demonicznymi, interpreter kończy działanie.

Na przykład przeglądarka HotJava używa do czterech wątków demona o nazwie „Moduł pobierania obrazu” do pobierania obrazów z systemu plików lub sieci dla dowolnego wątku, który tego potrzebuje.

Wątki demona są zwykle używane do wykonywania usług dla aplikacji / apletu (takich jak ładowanie „bitów fiddley”). Zasadnicza różnica między wątkami użytkownika a wątkami demona polega na tym, że JVM zamknie program dopiero po zakończeniu wszystkich wątków użytkownika. Wątki demonów są kończone przez JVM, gdy nie są już uruchomione żadne wątki użytkownika, w tym główny wątek wykonania.

setDaemon (prawda / fałsz)? Ta metoda służy do określenia, że ​​wątek jest wątkiem demona.

public boolean isDaemon ()? Ta metoda służy do ustalenia, czy wątek jest wątkiem demona, czy nie.

Na przykład:

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");
    }

}

Wynik:

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>

Definicja demona (Computing):

Proces w tle, który obsługuje żądania usług, takich jak buforowanie wydruku i przesyłanie plików, i jest nieaktywny, gdy nie jest wymagany.

—— Źródło: angielski przez Oxford Dictionaries

Co to jest wątek Daemon w Javie?

• Wątki demona mogą zostać zamknięte w dowolnym momencie pomiędzy ich przepływem, Non-Daemon, tzn. Wątek użytkownika wykonuje się całkowicie.
• Wątki demonów to wątki działające sporadycznie w tle, o ile działają inne wątki niebędące demonami.
• Po zakończeniu wszystkich wątków innych niż demony wątki demonów kończą się automatycznie.
• Wątki demona są dostawcami usług dla wątków użytkowników działających w tym samym procesie.
• JVM nie dba o to, aby wątki demona zostały ukończone w stanie Uruchomionym, nawet w końcu blok nie pozwala na wykonanie. JVM preferuje wątki inne niż demon, które są tworzone przez nas.
• Wątki demona działają jako usługi w systemie Windows.
• JVM zatrzymuje wątki demona, gdy wszystkie wątki użytkownika (w przeciwieństwie do wątków demona) są zakończone. W związku z tym wątki demona można wykorzystać do implementacji, na przykład, funkcji monitorowania, gdy JVM zatrzymuje wątek, gdy tylko wszystkie wątki użytkownika zostaną zatrzymane.

Wątek demon jest wątek, który jest uważany robi pewne zadania w tle jak rozpatrywania wniosków lub różnych chronjobs które mogą występować w aplikacji.

Gdy w twoim programie pozostaną tylko wątki demona , zakończy działanie. Jest tak, ponieważ zwykle te wątki współpracują z normalnymi wątkami i zapewniają obsługę zdarzeń w tle.

Możesz określić, że a Threadjest demonem za pomocą setDaemonmetody, zwykle nie wychodzą, ani nie są przerywane. Po prostu zatrzymują się, gdy aplikacja się zatrzyma.

Jedno nieporozumienie, które chciałbym wyjaśnić:

• Załóżmy, że jeśli wątek demona (powiedzmy B) jest tworzony w wątku użytkownika (powiedzmy A); zakończenie tego wątku użytkownika / wątku nadrzędnego (A) nie zakończy wątku demona / wątku potomnego (B), który utworzył; pod warunkiem, że wątek użytkownika jest jedynym aktualnie uruchomionym.
• Więc nie ma relacji rodzic-dziecko na zakończeniu wątku. Wszystkie wątki demona (niezależnie od tego, gdzie są tworzone) zakończą się, gdy nie będzie pojedynczego wątku aktywnego użytkownika, co spowoduje zakończenie pracy JVM.
• Nawet to jest prawdą dla obu (rodzica / dziecka) są wątkami demona.
• Jeśli wątek potomny utworzony z wątku demona, jest to również wątek demona. Nie będzie to wymagało żadnego jawnego ustawienia flagi wątku demona. Podobnie, jeśli wątek potomny utworzony z wątku użytkownika, jest to również wątek użytkownika, jeśli chcesz go zmienić, konieczne jest jawne ustawienie flagi demona przed rozpoczęciem tego wątku.

Wątek demona i wątki użytkownika. Zasadniczo wszystkie wątki utworzone przez programistę są wątkiem użytkownika (chyba że podasz go jako demon lub twój wątek nadrzędny jest demonem). Wątek użytkownika jest zasadniczo przeznaczony do uruchamiania naszego kodu programu. JVM nie kończy się, dopóki nie zakończy się cały wątek użytkownika.

Java ma specjalny rodzaj wątku zwany demonem wątku.

• Bardzo niski priorytet.
• Wykonuje się tylko, gdy nie działa żaden inny wątek tego samego programu.
• JVM kończy program kończąc te wątki, gdy wątki demona są jedynymi wątkami działającymi w programie.

Do czego służą wątki demonów?

Zwykle używany jako usługodawca dla normalnych wątków. Zwykle mają nieskończoną pętlę, która czeka na zgłoszenie serwisowe lub wykonuje zadania wątku. Nie mogą wykonywać ważnych prac. (Ponieważ nie wiemy, kiedy będą mieli czas procesora i mogą zakończyć w dowolnym momencie, jeśli nie są uruchomione żadne inne wątki).

Typowym przykładem tego rodzaju wątków jest moduł śmieciowy Java .

Jest więcej...

• Wywołujesz setDaemon()metodę dopiero przed wywołaniem start()metody. Po uruchomieniu wątku nie można modyfikować jego statusu demona.
• Użyj isDaemon()metody, aby sprawdzić, czy wątek jest wątkiem demona czy wątkiem użytkownika.

Wątki demonów są jak asystenci. Wątki inne niż demony są jak czołowi wykonawcy. Asystenci pomagają wykonawcom w ukończeniu pracy. Po zakończeniu zadania wykonawcy nie potrzebują już pomocy do wykonania. Ponieważ pomoc nie jest potrzebna, asystenci opuszczają to miejsce. Kiedy zadania wątków innych niż demon zostaną zakończone, wątki demona znikają.

Wątek demona jest jak normalny wątek, z tą różnicą, że JVM zostanie zamknięty tylko wtedy, gdy inne wątki inne niż demon nie istnieją. Wątki demonów są zwykle używane do świadczenia usług dla aplikacji.

Wątek demona w Javie to wątek działający w tle i najczęściej tworzony przez JVM do wykonywania zadań w tle, takich jak odśmiecanie i inne zadania związane z utrzymaniem domu.

Punkty do odnotowania:

1. Każdy wątek utworzony przez główny wątek, który uruchamia główną metodę w Javie, domyślnie nie jest demonem, ponieważ Thread dziedziczy naturę demona od wątku, który go tworzy, tj. Wątku macierzystego, a ponieważ wątek główny jest wątkiem innym niż demon, każdy inny wątek utworzony z niego będzie pozostają nie-demonami, dopóki jawnie nie stanie się demonem, wywołując setDaemon (true).

2. Thread.setDaemon (true) tworzy demona wątku, ale można go wywołać tylko przed uruchomieniem wątku w Javie. Zgłasza IllegalThreadStateException, jeśli odpowiedni wątek jest już uruchomiony i uruchomiony.

Różnica między wątkiem Daemon i Non Daemon w Javie:

1) JVM nie czeka na zakończenie żadnego wątku demona.

2) Wątek demona jest traktowany inaczej niż wątek użytkownika, gdy JVM kończy działanie, w końcu bloki nie są wywoływane, stosy nie są rozwijane, a JVM po prostu wychodzi.

W Javie wątki demona są jednym z typów wątku, który nie uniemożliwia wyjścia wirtualnej maszyny Java (JVM). Głównym celem wątku demona jest wykonanie zadania w tle, szczególnie w przypadku rutynowych zadań okresowych lub pracy. Po wyjściu z JVM umiera również wątek demona.

Ustawienie a powoduje thread.setDaemon(true), że wątek staje się wątkiem demona. Można jednak ustawić tę wartość tylko przed rozpoczęciem wątku.

Oto przykład, aby przetestować zachowanie wątków demona w przypadku wyjścia jvm z powodu braku wątków użytkownika.

Zwróć uwagę na ostatni ostatni wiersz w wynikach poniżej, gdy główny wątek zakończył działanie, wątek demona również umarł i nie wypisał instrukcji wykonanej ostatecznie9 w bloku ostatecznie. Oznacza to, że wszelkie zasoby we / wy zamknięte w końcu bloku wątku demona nie zostaną zamknięte, jeśli JVM zakończy działanie z powodu nieistnienia wątków użytkownika.

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");
  }
}

Wynik

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

Wątki demonów są, jak wszyscy wyjaśnili, nie ograniczają JVM do wyjścia, więc w zasadzie jest to szczęśliwy wątek dla aplikacji z punktu widzenia wyjścia.

Chcę dodać, że wątków demona można użyć, gdy powiedzę, że udostępniam interfejs API, np. Wypychając dane na serwer zewnętrzny lub JMS, może być konieczne agregowanie danych na poziomie JVM klienta, a następnie wysyłanie do JMS osobnego wątku. Mogę utworzyć ten wątek jako wątek demona, jeśli nie są to dane obowiązkowe, które należy przekazać na serwer. Tego rodzaju dane są jak push log / agregacja.

Pozdrawiam, Manish

Wątek demona jest jak proces demona, który jest odpowiedzialny za zarządzanie zasobami, wątek demona jest tworzony przez maszynę wirtualną Java w celu obsługi wątków użytkownika. przykładowy system aktualizacji dla unixa, unix to proces demona. potomek wątku demona jest zawsze wątkiem demona, więc domyślnie demon ma wartość false. możesz sprawdzić wątek jako demona lub użytkownika za pomocą metody „isDaemon ()”. więc wątek lub proces demona są w zasadzie odpowiedzialne za zarządzanie zasobami. na przykład podczas uruchamiania jvm uruchomiony jest moduł czyszczenia pamięci, który jest wątkiem demona, którego priorytetem jest 1, który jest najniższy, który zarządza pamięcią. jvm żyje tak długo, jak wątek użytkownika jest aktywny, nie możesz zabić demona thread.jvm jest odpowiedzialny za zabicie wątków demona.

Porozmawiajmy tylko w kodzie z działającymi przykładami. Podoba mi się powyższa odpowiedź Russa, ale aby usunąć wszelkie wątpliwości, trochę ją ulepszyłem. Uruchomiłem go dwa razy, raz z wątkiem roboczym ustawionym na deamon true (wątek deamon), a innym razem na false (wątek użytkownika). Potwierdza, że ​​nić diamon kończy się, gdy kończy się nić główna.

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

Wątki demonów są ogólnie znane jako wątki „usługodawcy”. Wątków tych nie należy używać do wykonywania kodu programu, ale kodu systemowego. Wątki te działają równolegle do kodu, ale JVM może je zabić w dowolnym momencie. Gdy JVM nie znajdzie wątków użytkownika, zatrzymuje je, a wszystkie wątki demona kończą się natychmiast. Możemy ustawić wątek inny niż demon na demona, używając:

setDaemon(true)

Wątki demonów są wątkami działającymi w tle, dopóki inne wątki procesu inne niż demony są nadal uruchomione. Zatem po zakończeniu wszystkich wątków nie-demonów wątki demonów zostają zakończone. Przykładem wątku niebędącego demonem jest wątek uruchamiający Main. Wątek jest demonem poprzez wywołaniesetDaemon() metody przed uruchomieniem wątku

Więcej informacji: wątek Daemon w Javie

Dla mnie wątek demona jest jak opiekun domu dla wątków użytkowników. Jeśli wszystkie wątki użytkownika zakończą się, wątek demona nie ma zadania i zostaje zabity przez maszynę JVM. Wyjaśniłem to w filmie na YouTube .

JVM wykona pracę po zakończeniu ostatniego wykonania wątku nie-demona. Domyślnie JVM utworzy wątek jako nondaemon, ale możemy zrobić wątek jako demon za pomocą metody setDaemon(true). Dobrym przykładem wątku Daemon jest wątek GC, który zakończy swoją pracę, gdy tylko wszystkie wątki nondaemon zostaną zakończone.

Wątki demonów umierają po wyjściu wątku twórcy.

Wątki inne niż demony (domyślne) mogą nawet żyć dłużej niż główny wątek.

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