Java 7 Concurrency Cookbook 翻译 第一章 线程管理之五

九、使用线程本地变量

　　一个并发程序的最关键特征就是共享数据。这个特性在那些继承了 Thread 类或者 实现了 Runnable 接口的对象上显得更加重要。

　　如果你创建一个实现了 Runnable 接口的对象，然后再使用多个 Thread 对象去运行这个相同 Runnable 对象，这样所有的 Thread 对象就会共享相同的属性。这意味着你在其中一个 Thread 对象中对属性做的修改会影响其他的 Thread 对象。

　　有时，你需要运行同一个 Runnable 对象的多个 Thread 对象都有自己的独立的属性，而不是共享一个。Java的并发 API 中提供了一个高效且清晰的机制叫做线程本地变量来实现此特性。

　　在本秘诀中，我们首先开发一个程序来演示问题，然后使用线程本地变量的机制在另一个程序中来解决这个问题。

public class UnsafeTask implements Runnable {
    private Date startDate;

    @Override
    public void run() {
        startDate = new Date();
        System.out.printf("Starting Thread: %s : %s\n", Thread.currentThread().getId(),
                startDate);
        try {
            TimeUnit.SECONDS.sleep((int) Math.rint(Math.random()*10));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("Thread Finished: %s : %s\n", Thread.currentThread().getId(),
                startDate);
    }

}

public class Core {
    public static void main(String[] args) {
        SafeTask task = new SafeTask();
        for (int i = 0; i < 3; i++) {
            Thread thread = new Thread(task);
            thread.start();

            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class SafeTask implements Runnable {
    private static ThreadLocal<Date> startDate = new ThreadLocal<Date>() {
        protected Date initialValue() {
            return new Date();
        }
    };

    @Override
    public void run() {
        System.out.printf("Starting Thread: %s : %s\n", Thread.currentThread().getId(),
                startDate.get());
        try {
            TimeUnit.SECONDS.sleep((int) Math.rint(Math.random()*10));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("Thread Finished: %s : %s\n", Thread.currentThread().getId(),
                startDate.get());
    }

}

　　在没有使用线程本地变量之前，在程序执行结束后，所有线程的时间都相等，在使用了线程本地变量之后，线程的时间就不相等了。

　　线程本地变量针对每一个属性为每一个线程保存有自己的值。你可以使用 get() 和 set() 方法来分别获取和设置属性的值。线程本地变量的 initialValue() 方法会在该变量第一次被访问的时候执行，可以用来设置初始值。

　　注意：线程本地变量还有一个 remove() 方法可以方便地用来溢出线程线程本地变量。

　　Java并发API中的 inheritableThreadLocal 类提供了子线程对父线程线程本地变量的继承性。举例来说就是：线程A有一个本地变量的值是X，如果线程A产生了线程B，那么线程B也具有本地变量且值也是X。当然，你可以通过覆写该类的 childValue() 方法来定制行为。

十、聚集多个线程成线程组

　　Java并发API提高了一个有趣的功能：聚集线程成线程组。线程组使得我们可以以一个整体的形式来操控线程组内的所有线程。举例来说，你想控制一些执行相同任务的线程，这时把它们聚集成线程组，你对线程组使用一次调用就对它们每一个发出了相同的调用。

　　Java中线程组的对应类就是 ThreadGroup 类。ThreadGroup 对象可以从 Thread 对象或者 ThreadGroup 对象构造而来，相互组合可以形成树状结构。

　　在本秘诀中，我们使用 ThreadGroup 来达到如下场景：线程组内的10个线程执行耗时不同的任务，一旦一个执行完毕，终结组内所有线程。

　　　

public class Main {
    public static void main(String[] args) {
        ThreadGroup threadGroup = new ThreadGroup("Searcher");
        Result result = new Result();
        SearchTask searchTask = new SearchTask(result);

        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(threadGroup, searchTask);
            thread.start();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.printf("Number of Threads: %d\n", threadGroup.activeCount());
        System.out.printf("Infomation about the Thread Group\n");
        threadGroup.list();

        Thread[] threads = new Thread[threadGroup.activeCount()];
        threadGroup.enumerate(threads);
        for (int i = 0; i < threadGroup.activeCount(); i++) {
            System.out.printf("Thread %s: %s\n", threads[i].getName(), threads[i].getState());
        }

        waitFinish(threadGroup);
        threadGroup.interrupt();
    }

    private static void waitFinish(ThreadGroup threadGroup) {
        while (threadGroup.activeCount() > 4) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Result {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public class SearchTask implements Runnable {
    private Result result;
    public SearchTask(Result result) {
        this.result = result;
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.printf("Thread %s: Start\n", name);
        try {
            doTask();
            result.setName(name);
        } catch (InterruptedException e) {
            System.out.printf("Thread %s: Interrupted\n", name);
            return;
        }
        System.out.printf("Thread %s: End\n", name);
    }

    private void doTask() throws InterruptedException {
        Random random = new Random((new Date()).getTime());
        int value = (int) (random.nextDouble()*100);
        System.out.printf("Thread %s: %d\n", Thread.currentThread().getName(), value);
        TimeUnit.SECONDS.sleep(value);
    }
}

　　ThreadGroup 类存储了与其相关联的 Thread 对象和 ThreadGroup 对象，所以其可以很方便地访问它们的状态和控制它们。

重要：本系列翻译文档也会在本人的微信公众号(此山是我开)第一时间发布，欢迎大家关注。