Java并发编程示例(九)：本地线程变量的使用_java

共享数据是并发程序最关键的特性之一。对于无论是继承Thread类的对象，还是实现Runnable接口的对象，这都是一个非常周重要的方面。

如果创建了一个实现Runnable接口的类的对象，并使用该对象启动了一系列的线程，则所有这些线程共享相同的属性。换句话说，如果一个线程修改了一个属性，则其余所有线程都会受此改变的影响。

有时，我们更希望能在线程内单独使用，而不和其他使用同一对象启动的线程共享。Java并发接口提供了一种很清晰的机制来满足此需求，该机制称为本地线程变量。该机制的性能也非常可观。

知其然

按照下面所示步骤，完成示例程序。

1.首先，实现一个有上述问题的程序。创建一个名为UnsafeTask的类，并且实现Runnable接口。在类中声明一个java.util.Date类型的私有属性。代码如下：

复制代码 代码如下:

public class UnsafeTask implements Runnable {
    private Date startDate;

2.实现UnsafeTask的run()方法，该方法实例化startDate属性，并将其值输出到控制台上。休眠随机一段时间，然后再次将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);
}

3.实现问题程序的主类。创建一个带有main()方法的类，UnsafeMain。在main()方法中，创建一个UnsafeTask对象，并使用该对象来创建10个Thread对象，来启动10个线程。在每个线程中间，休眠2秒钟。代码如下：

复制代码 代码如下:

public class UnsafeMain {
    public static void main(String[] args) {
        UnsafeTask task = new UnsafeTask();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(task);
            thread.start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.从上面的逻辑来看，每个线程都有一个不同的启动时间。但是，根据下面的输出日志来看，出现了好多相同的时间值。如下：

复制代码 代码如下:

Starting Thread: 9 : Sun Sep 29 23:31:08 CST 2013
Starting Thread: 10 : Sun Sep 29 23:31:10 CST 2013
Starting Thread: 11 : Sun Sep 29 23:31:12 CST 2013
Starting Thread: 12 : Sun Sep 29 23:31:14 CST 2013
Thread Finished: 9 : Sun Sep 29 23:31:14 CST 2013
Starting Thread: 13 : Sun Sep 29 23:31:16 CST 2013
Thread Finished: 10 : Sun Sep 29 23:31:16 CST 2013
Starting Thread: 14 : Sun Sep 29 23:31:18 CST 2013
Thread Finished: 11 : Sun Sep 29 23:31:18 CST 2013
Starting Thread: 15 : Sun Sep 29 23:31:20 CST 2013
Thread Finished: 12 : Sun Sep 29 23:31:20 CST 2013
Starting Thread: 16 : Sun Sep 29 23:31:22 CST 2013
Starting Thread: 17 : Sun Sep 29 23:31:24 CST 2013
Thread Finished: 17 : Sun Sep 29 23:31:24 CST 2013
Thread Finished: 15 : Sun Sep 29 23:31:24 CST 2013
Thread Finished: 13 : Sun Sep 29 23:31:24 CST 2013
Starting Thread: 18 : Sun Sep 29 23:31:26 CST 2013
Thread Finished: 14 : Sun Sep 29 23:31:26 CST 2013
Thread Finished: 18 : Sun Sep 29 23:31:26 CST 2013
Thread Finished: 16 : Sun Sep 29 23:31:26 CST 2013

5.如前文所示，我们准备使用本地线程变量（the thread-local variables）机制来解决这个问题。

6.创建一个名为SafeTask的类，并且实现Runnable接口。代码如下：

复制代码 代码如下:

public class SafeTask implements Runnable {

7.声明一个ThreadLocal<Date>类型的对象，该对象实例化时，重写了initialValue()方法，在该方法中返回实际的日期值。代码如下：

复制代码 代码如下:

private static ThreadLocal<Date> startDate = new
        ThreadLocal<Date>() {
            @Override
            protected Date initialValue() {
                return new Date();
            }
        };

8.实现SafeTask类的run()方法。该方法和UnsafeTask的run()方法一样，只是startDate属性的方法方式稍微调整一下。代码如下：

复制代码 代码如下:

@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());
}

9.该安全示例的主类和非安全程序的主类基本相同，只是需要将UnsafeTask修改为SafeTask即可。具体代码如下：

复制代码 代码如下:

public class SafeMain {
    public static void main(String[] args) {
        SafeTask task = new SafeTask();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(task);
            thread.start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

10.运行程序，分析两次输入的不同之处。

为了规范类的命名，本文中主类的命名和原文稍有不同。另外，原文程序和文字叙述不一致。应该是一个笔误。

知其所以然

下面是安全示例的执行结果。从结果中，可以很容易地看出，每个线程都有一个属于各自线程的startDate属性值。程序输入如下：

复制代码 代码如下:

Starting Thread: 9 : Sun Sep 29 23:52:17 CST 2013
Starting Thread: 10 : Sun Sep 29 23:52:19 CST 2013
Starting Thread: 11 : Sun Sep 29 23:52:21 CST 2013
Thread Finished: 10 : Sun Sep 29 23:52:19 CST 2013
Starting Thread: 12 : Sun Sep 29 23:52:23 CST 2013
Thread Finished: 11 : Sun Sep 29 23:52:21 CST 2013
Starting Thread: 13 : Sun Sep 29 23:52:25 CST 2013
Thread Finished: 9 : Sun Sep 29 23:52:17 CST 2013
Starting Thread: 14 : Sun Sep 29 23:52:27 CST 2013
Starting Thread: 15 : Sun Sep 29 23:52:29 CST 2013
Thread Finished: 13 : Sun Sep 29 23:52:25 CST 2013
Starting Thread: 16 : Sun Sep 29 23:52:31 CST 2013
Thread Finished: 14 : Sun Sep 29 23:52:27 CST 2013
Starting Thread: 17 : Sun Sep 29 23:52:33 CST 2013
Thread Finished: 12 : Sun Sep 29 23:52:23 CST 2013
Thread Finished: 16 : Sun Sep 29 23:52:31 CST 2013
Thread Finished: 15 : Sun Sep 29 23:52:29 CST 2013
Starting Thread: 18 : Sun Sep 29 23:52:35 CST 2013
Thread Finished: 17 : Sun Sep 29 23:52:33 CST 2013
Thread Finished: 18 : Sun Sep 29 23:52:35 CST 2013

线程本地变量为每个线程存储了一个属性的副本。可以使用ThreadLocal的get()方法获取变量的值，使用set()方法设置变量的值。如果第一次访问线程本地变量，并且该变量还没有赋值，则调用initialValue()方法为每个线程初始化一个值。

永无止境

ThreadLocal类还提供了remove()方法，来删掉调用该方法的线程中存储的本地变量值。

另外，Java并发API还提供了InheritableThreadLocal类，让子线程可以接收所有可继承的线程局部变量的初始值，以获得父线程所具有的值。如果线程A有一个线程本地变量，当线程A创建线程B时，则线程B将拥有和线程A一样的线程本地变量。还可以重写childValue()，来初始化子线程的线程本地变量。该方法将接受从父线程以参数形式传递过来的线程本地变量的值。

拿来主义

本文是从 《Java 7 Concurrency Cookbook》 （D瓜哥窃译为 《Java7并发示例集》 ）翻译而来，仅作为学习资料使用。没有授权，不得用于任何商业行为。

小有所成

下面是本节示例所包含的所有代码的完整版。

UnsafeTask类的完整代码：

复制代码 代码如下:

package com.diguage.books.concurrencycookbook.chapter1.recipe9;

import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * 不能保证线程安全的例子
 * Date: 2013-09-23
 * Time: 23:58
 */
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);
    }
}

UnsafeMain类的完整代码：

复制代码 代码如下:

package com.diguage.books.concurrencycookbook.chapter1.recipe9;

import java.util.concurrent.TimeUnit;

/**
 * 不安全的线程示例
 * Date: 2013-09-24
 * Time: 00:04
 */
public class UnsafeMain {
    public static void main(String[] args) {
        UnsafeTask task = new UnsafeTask();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(task);
            thread.start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

SafeTask类的完整代码：

复制代码 代码如下:

package com.diguage.books.concurrencycookbook.chapter1.recipe9;

import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * 使用线程本地变量保证线程安全
 * Date: 2013-09-29
 * Time: 23:34
 */
public class SafeTask implements Runnable {
    private static ThreadLocal<Date> startDate = new
            ThreadLocal<Date>() {
                @Override
                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());
    }
}

SafeMain类的完整代码：

复制代码 代码如下:

package com.diguage.books.concurrencycookbook.chapter1.recipe9;

import java.util.concurrent.TimeUnit;

/**
 * 安全的线程示例
 * Date: 2013-09-24
 * Time: 00:04
 */
public class SafeMain {
    public static void main(String[] args) {
        SafeTask task = new SafeTask();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(task);
            thread.start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

时间： 2024-08-03 03:13:48

Java并发编程示例(九)：本地线程变量的使用_java的相关文章

Java并发编程示例(十)：线程组_java

对线程分组是Java并发API提供的一个有趣功能.我们可以将一组线程看成一个独立单元,并且可以随意操纵线程组中的线程对象.比如,可以控制一组线程来运行同样的任务,无需关心有多少线程还在运行,还可以使用一次中断调用中断所有线程的执行. Java提供了ThreadGroup类来控制一个线程组.一个线程组可以通过线程对象来创建,也可以由其他线程组来创建,生成一个树形结构的线程. 根据<Effective Java>的说明,不再建议使用ThreadGroup.建议使用Executor. --D瓜哥特此

Java并发编程示例(一)：线程的创建和执行_java

开门见山 在IT圈里,每当我们谈论并发时,必定会说起在一台计算机上同时运行的一系列线程.如果这台电脑上有多个处理器或者是一个多核处理器,那么这时是实实在在的"同时运行":但是,如果计算机只有一个单核处理器,那么这时的"同时运行"只是表象而已. 所有的现代操作系统全部支持任务的并发执行.你可以边听音乐,边上网看新闻,还不耽误首发电子邮件.我们可以说,这种并发是 进程级并发 .在进程内部,我也可以看到有许许多多的并发任务.我们把运行在一个进程里面的并发任务称 线程. 和

Java并发编程示例(三)：线程中断_java

一个多线程的Java程序,直到所有线程执行完成,整个程序才会退出.(需要注意的是,是所有非后台线程(non-daemon thread)执行完成:如果一个线程执行了System.exit()方法,程序也会退出.)有时,你想中止一个线程的执行,例如你想退出程序,或者你想取消一个正在执行的任务等. Java提供了中断机制,可以让我们显式地中断我们想中止执行的线程.中断机制的一个特征就是我们可以检查线程是否已经被中断,进而决定是否响应中止请求.线程也可以忽略中止请求,继续执行. 在本节,我们所开发的示

Java并发编程之性能、扩展性和响应_java

本文讨论的重点在于多线程应用程序的性能问题.我们会先给性能和扩展性下一个定义,然后再仔细学习一下Amdahl法则.下面的内容我们会考察一下如何用不同的技术方法来减少锁竞争,以及如何用代码来实现. 1.性能 我们都知道,多线程可以用来提高程序的性能,背后的原因在于我们有多核的CPU或多个CPU.每个CPU的内核都可以自己完成任务,因此把一个大的任务分解成一系列的可彼此独立运行的小任务就可以提高程序的整体性能了.可以举个例子,比如有个程序用来将硬盘上某个文件夹下的所有图片的尺寸进行修改,应用多线程技

Java并发编程示例(四)：可控的线程中断_java

在上一节"线程中断"中,我们讲解了如何中断一个正在执行的线程以及为了中断线程,我们必须对Thread动点什么手脚.一般情况下,我们可以使用上一节介绍的中断机制.但是,如果线程实现了一个分配到多个方法中的复杂算法,或者方法调用中有一个递归调用,我们应该使用更好的方式来控制线程的中断.为此,Java提供了InterruptedException异常.当检测到中断请求时,可以抛出此异常,并且在run()方法中捕获. 在本节,我们将使用一个线程查找指定目录及其子目录下文件来演示通过使用Inte

Java并发编程中的生产者与消费者模型简述_java

概述对于多线程程序来说,生产者和消费者模型是非常经典的模型.更加准确的说,应该叫"生产者-消费者-仓库模型".离开了仓库,生产者.消费者就缺少了共用的存储空间,也就不存在并非协作的问题了. 示例定义一个场景.一个仓库只允许存放10件商品,生产者每次可以向其中放入一个商品,消费者可以每次从其中取出一个商品.同时,需要注意以下4点: 1.  同一时间内只能有一个生产者生产,生产方法需要加锁synchronized. 2.  同一时间内只能有一个消费者消费,消费方法需要加锁synchroni

Java并发编程示例(八)：处理线程的非受检异常_java

Java语言中,把异常分为两类: 受检异常: 这类异常必须在throws子句中被显式抛出或者在方法内被捕获.例如,IOException异常或ClassNotFoundException异常.非受检异常: 这类异常不需要显式抛出或捕获.例如,NumberFormatException异常. 当一个受检异常在Thread对象的run()方法中被抛出时,我们必须捕获并处理它,因为run()方法不能抛出异常.而一个非受检异常在Thread对象的run()方法中被抛出时,默认的行为是在控制台打印出堆栈跟

Java并发编程示例(六)：等待线程执行终止_java

在某些场景下,我们必须等待线程执行完成才能进行下一步工作.例如,某些程序在开始执行之前,需要先初始化一些资源.这时,我们可以启动一个线程专门来做初始化任务,等到线程任务完成后,再去执行其他部分. 为此,Thread类为我们提供了join()方法.当我们使用线程对象调用此方法时,正在掉调用的线程对象将被推迟到被调用对象执行完成后再开始执行. 在本节,示例程序演示等待初始化方法完成后,再去执行其他任务. 知其然 按照下面所示步骤,完成示例程序. 1.创建一个名为DataSourcesLoader的类

Java并发编程示例(七)：守护线程的创建和运行_java

Java有一种特殊线程,守护线程,这种线程优先级特别低,只有在同一程序中的其他线程不执行时才会执行. 由于守护线程拥有这些特性,所以,一般用为为程序中的普通线程(也称为用户线程)提供服务.它们一般会有一个无限循环,或用于等待请求服务,或用于执行任务等.它们不可以做任何重要的工作,因为我们不确定他们什么时才能分配到CPU运行时间,而且当没有其他线程执行时,它们就会自动终止.这类线程的一个典型应用就是Java的垃圾回收. 在本节示例中,我们将创建两个线程,一个是普通线程,向队列中写入事件:另外一个是