Co się dzieje z wątkami potomnymi, kiedy wątek rodzic się skończy?

Załóżmy, że mam wątek A który uruchamia wątki B i C. Co się stanie z wątkami B i C gdy wątek a zakończy swoje działanie? Mam problem tutaj:

public class Letters extends Thread implements Iterable<Thread>
{
    private String chars;

    private Thread[] threads;
    int index = 0;

    public Letters(String chars)
    {
        this.chars = chars;
        this.threads = new Thread[chars.length()];

        for (int i = 0; i < threads.length; i++)
        {
            int finalI = i;
            Thread thread = new Thread()
            {
                @Override
                public void run()
                {
                    while (!Letters.this.isInterrupted())
                    {
                        System.out.print(chars.charAt(finalI));
                        try
                        {
                            Thread.sleep((int) (Math.random() * 2000));
                        }
                        catch (InterruptedException e)
                        {
                            throw new RuntimeException(e);
                        }
                    }
                }
            };

            threads[finalI] = thread;
        }
    }

    @Override
    public void run()
    {
        for (Thread thread : threads)
        {
            thread.start();
        }

        while (true)
        {
            if (this.isInterrupted())
                return;
        }
    }

    Iterator<Thread> threadsIterator = new Iterator<Thread>()
    {
        @Override
        public boolean hasNext()
        {
            return index < threads.length;
        }

        @Override
        public Thread next()
        {
            return threads[index++];
        }
    };

    @Override
    public Iterator iterator()
    {
        return threadsIterator;
    }
}

i metoda main:

public static void main(String[] args)
{
    Letters letters = new Letters("ABCD");


    for (Thread t : letters)
        System.out.println(t.getName() + " starting");

    letters.start();
    try
    {
        Thread.sleep(5000);
    }
    catch(InterruptedException ignore)
    {

    }
    letters.interrupt();
    System.out.println("\nProgram completed.");
}

Nie rozumiem do końca różnicy między isInterrupted() i interrupted():

while (true)
{
    if (this.isInterrupted())
        return;
}

Gdy w warunku if użyję metody Thread.interrupted() to wtedy zostanie tylko zakończone wykonywanie metody run klasy letters ale już wątków uruchomionych przez tą metode nie. Jeśli użyję isInterrupted() to program kończy swoje działanie.

Jeżeli się nie mylę, to kwestia tego: interrupted to metoda statyczna, która po wywołaniu clearuje potencjalny status interrupta. Z Javadoca:

Tests whether the current thread has been interrupted. The interrupted status of the thread is cleared by this method. In other words, if this method were to be called twice in succession, the second call would return false (unless the current thread were interrupted again, after the first call had cleared its interrupted status and before the second call had examined it).

Z tego co widze to "literowe" wątki przerwą się wtedy i tylko wtedy kiedy wątek na którym jest obiekt Letters jest interrupted. Kiedy wołasz Thread.interrupted(), to jeśli thread będzie faktycznie interrupted, to ta metoda ustawi flagę isInterrupted na false. Wątek letters potem kończy się, ale nadal nie jest interrupted. Przez to te wątki pracują dalej.

Dzięki za odpowiedź @summazen. Co uważacie o rozdziale na temat programowania współbieżnego z Thinking in Java, ta książka jest do Javy 5. Może to być dobre wprowadzenie, aby ogarnąć podstawy, czy jednak po Javie 5 sporo się zmieniło i lepiej poszukać czegoś innego?

wydra__ napisał(a):

Dzięki za odpowiedź @summazen. Co uważacie o rozdziale na temat programowania współbieżnego z Thinking in Java, ta książka jest do Javy 5. Może to być dobre wprowadzenie, aby ogarnąć podstawy, czy jednak po Javie 5 sporo się zmieniło i lepiej poszukać czegoś innego?

Jak chcesz zrozumieć współbiegi z wszelkimi niuansami to polecam Java concurrency in practice od Goetza, cokolwiek starszego niż java 8 to moim zdaniem dinozaury

Nie wiem na jakim poziomie jesteś ale:

1. W Javie wszedł wreszcie project Loom (która Java, ktoś pamięta numer?) który zmienia trochę sytuację dla operacji czekających na dane. Zamiast czekać na dane w threadzie (watku), lepiej czekać w fiberze (włóknie)
2. W pracy Java developera rzadko manipuluje się wątkami manualnie. No chyba że jesteś jednym z tych nielicznych co piszą biblioteki do manipularania wątkami jak Akka czy Cats-effects

summazen napisał(a):

Jak chcesz zrozumieć współbiegi z wszelkimi niuansami to polecam Java concurrency in practice od Goetza, cokolwiek starszego niż java 8 to moim zdaniem dinozaury

Czyli jesteś miłośnikiem dinozaurów? ;) Bo ta ksiązka jest z 2006 roku, a Java 8 z 2014 roku.

No ale z tego co zrobiłem mały research to i tak chyba nic lepszego niż ta książka od Goetza nie ma.

Do wielowątkowości niskopoziomowej zapewne tak, ale powstało też trochę mechanizmów wysokopoziomowych w nowszych wersjach Javy i też trzeba je znać.