Java线程和并发 - Additional Thread Capabilities

Thread Groups

如果看Thread类，可能会发现它的构造器、activeCount()方法等地方都引用了ThreadGroup类。
JDK文档说，线程组代表线程的集合。而且，线程组可以包含其他线程组。线程组形成了一棵树。
使用ThreadGroup对象，可以执行在它包含的线程对象上的操作。比如，假如tg引用了一个线程组，那么tg.suspend()会暂停该组内的全部线程。线程组简化了线程的管理。
尽管ThreadGroup很有用，基于如下原因，还是应该尽量不使用它：

• ThreadGroup中最有用的方法是void suspend()、void resume()和void stop()。它们已经被deprecated了，这是因为像他们的线程同行一样，容易带来死锁和其他问题
• ThreadGroup不是线程安全的。比如，要获得一个线程租内的活动线程数，你应该调用activeCount()方法。然后你想使用该值传给enumerate()方法。但是，无法保证计数是准确的，这是因为，两次调用之间，数量可能已经改变了。如果数组小，enumerate()只是忽略多余的线程。这个问题，可以参见time of check to time of use

不过，你还是应该了解当线程执行过程中抛异常时，ThreadGroup所做的贡献。下面的代码会抛ArithmeticException：

public class ExceptionThreadDemo {
    public static void main(String[] args) {
        Runnable r = () -> {
            int x = 1 / 0; //
        };
        Thread thd = new Thread(r);
        thd.start();
    }
}

执行结果是：

Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
	at jdk.ExceptionThreadDemo.lambda$main$0(ExceptionThreadDemo.java:9)
	at java.lang.Thread.run(Thread.java:745)

当run()方法抛异常的时候，线程退出，接下来发生了：

• JVM寻找线程的实例。如果通过setUncaughtExceptionHandler方法设置了UncaughtExceptionHandler，就执行线程的void uncaughtException(Thread t, Throwable e)方法-t是抛异常的线程，e是异常或者错误（比如OutOfMemoryError）。如果uncaughtException()也抛异常/错误，JVM就忽略它
• 如果没有用setUncaughtExceptionHandler()安装一个处理器，JVM就转交给对应的线程组的uncaughtException方法处理。如果所有的父线程组都没有设置，就使用看是否有默认的处理器（由线程的静态setDefaultUncaughtExceptionHandler方法设置）。否则，uncaughtException()检查Throwable参数，看是否是ThreadDeath的实例，如果是，不做什么处理;如果不是，像上面那样打印错误信息

下面的程序演示了setUncaughtExceptionHandler()和setDefaultUncaughtExceptionHandler()方法：

public class ExceptionThreadDemo {
    public static void main(String[] args) {
        Runnable r = () -> {
            int x = 1 / 0; //
        };
        Thread thd = new Thread(r);
        Thread.UncaughtExceptionHandler uceh;
        uceh = (Thread t, Throwable e) -> System.out.println("Caught throwable " + e + " for thread " + t);
        thd.setUncaughtExceptionHandler(uceh);

        uceh = (Thread t, Throwable e) -> {
            System.out.println("Default uncaught exception handler");
            System.out.println("Caught throwable " + e + " for thread " + t);
        };
        Thread.setDefaultUncaughtExceptionHandler(uceh);
        thd.start();
    }
}

Thread-Local Variables

有时候，你想给每个线程关联数据（比如用户ID），使用ThreadLocal可以很方便地实现这个功能。
每个ThreadLocal实例描述一个线程本地变量，该对象为每个线程提供了独立的存储槽-每个线程能为同一个变量保存不同的值，每个线程只能看到自己的值。
ThreadLocal有下列构造器和方法：

• ThreadLocal()：增加一个新的线程本地变量
• T get()：返回调用线程的存储槽内的值。如果条目不存在，get()调用initialValue()
• T initialValue()：增加一个调用线程的存储槽，保存初始值（默认）值。默认的初始值是null。应该覆盖该方法，提供更合适的初始值
• void remove()：删除调用线程的存储槽
• void set(T value)：在调用线程的存储槽中设置值

下面的程序，有两个线程，每个线程保存了用户ID：

public class ThreadLocalDemo {
    private static volatile ThreadLocal<String> userID = new ThreadLocal<String>();

    public static void main(String[] args) {
        Runnable r = () -> {
            String name = Thread.currentThread().getName();
            if (name.equals("A"))
                userID.set("foxtrot");
            else
                userID.set("charlie");
            System.out.println(name + " " + userID.get());
        };
        Thread thdA = new Thread(r);
        thdA.setName("A");
        Thread thdB = new Thread(r);
        thdB.setName("B");
        thdA.start();
        thdB.start();
    }
}

保存在线程本地变量的指是不相关的。当增加一个新线程的时候，它得到一个新存储槽，包含initialValue()的值。也许你想从父线程传一个值-一个线程增加另一个线程，把值传给新增加的子线程。你可以使用InheritableThreadLocal。
InheritableThreadLocal是ThreadLocal的子类。它声明了下面的protected方法：

• T childValue(T parentValue)：计算子的初始值。该方法由父线程在子线程开始前调用

public class InheritableThreadLocalDemo {
    private static final InheritableThreadLocal<Integer> intVal = new InheritableThreadLocal<>();
    
    public static void main(String[] args)
    {
        Runnable rP = () ->
        {
            intVal.set(10);
            Runnable rC = () ->
            {
                Thread thd = Thread.currentThread();
                String name = thd.getName();
                System.out.printf("%s %d%n", name, intVal.get());
            };
            Thread thdChild = new Thread(rC);
            thdChild.setName("Child");
            thdChild.start();
        };
        new Thread(rP).start();
    }
}