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

(0)

相关推荐

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

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

  • Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁

    在Java5.0之前,只有synchronized(内置锁)和volatile. Java5.0后引入了显示锁ReentrantLock. ReentrantLock概况 ReentrantLock是可重入的锁,它不同于内置锁, 它在每次使用都需要显示的加锁和解锁, 而且提供了更高级的特性:公平锁, 定时锁, 有条件锁, 可轮询锁, 可中断锁. 可以有效避免死锁的活跃性问题.ReentrantLock实现了 Lock接口: 复制代码 代码如下: public interface Lock {  

  • Java并发编程示例(二):获取和设置线程信息

    Thread类包含几个属性,这些属性所表示的信息能帮助我们识别线程.观察其状态.控制其优先级等.这些线程包括如下几种: ID: 该属性表示每个线程的唯一标识: Name: 该属性存储每个线程的名称: Priority: 该属性存储每个Thread对象的优先级.线程优先级分1到10十个级别,1表示最低优先级,10表示最高优先级.并不推荐修改线程的优先级,但是如果确实有这方面的需求,也可以尝试一下. Status: 该属性存储线程的状态.线程共有六种不同的状态:新建(new).运行(runnable

  • Java并发编程示例(五):线程休眠与恢复

    有时,我们需要在指定的时间点中断正在执行的线程.比如,每分钟检查一次传感器状态的线程,其余时间,线程不需要做任何事情.在此期间,线程不需要使用计算机的任何资源.过了这段时间之后,并且当Java虚拟机调度了该线程,则该线程继续执行.为此,你可以使用Thread类的sleeep()方法.该方法以休眠的方式来推迟线程的执行,而且整数类型的参数则指明休眠的毫秒数.当调用sleep()方法,休眠时间结束后,Java虚拟机分配给线程CPU运行时间,线程就会继续执行. 另一种是用sleep()方法的方式是通过

  • Java并发编程之栅栏(CyclicBarrier)实例介绍

    栅栏类似闭锁,但是它们是有区别的. 1.闭锁用来等待事件,而栅栏用于等待其他线程.什么意思呢?就是说闭锁用来等待的事件就是countDown事件,只有该countDown事件执行后所有之前在等待的线程才有可能继续执行;而栅栏没有类似countDown事件控制线程的执行,只有线程的await方法能控制等待的线程执行. 2.CyclicBarrier强调的是n个线程,大家相互等待,只要有一个没完成,所有人都得等着. 场景分析:10个人去春游,规定达到一个地点后才能继续前行.代码如下 复制代码 代码如

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

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

  • 深入探究Java多线程并发编程的要点

    关键字synchronized synchronized关键可以修饰函数.函数内语句.无论它加上方法还是对象上,它取得的锁都是对象,而不是把一段代码或是函数当作锁. 1,当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一段时间只能有一个线程得到执行,而另一个线程只有等当前线程执行完以后才能执行这块代码. 2,当一个线程访问object中的一个synchronized(this)同步代码块时,其它线程仍可以访问这个object中是其它非synchr

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

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

  • Java并发编程示例(十):线程组

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

  • Java并发编程之显式锁机制详解

    我们之前介绍过synchronized关键字实现程序的原子性操作,它的内部也是一种加锁和解锁机制,是一种声明式的编程方式,我们只需要对方法或者代码块进行声明,Java内部帮我们在调用方法之前和结束时加锁和解锁.而我们本篇将要介绍的显式锁是一种手动式的实现方式,程序员控制锁的具体实现,虽然现在越来越趋向于使用synchronized直接实现原子操作,但是了解了Lock接口的具体实现机制将有助于我们对synchronized的使用.本文主要涉及以下一些内容: 接口Lock的基本组成成员 可重入锁Re

随机推荐