java多线程与线程并发四：线程范围内的共享数据

当多个线程操作同一个共有数据时，一个线程对共有数据的改变会影响到另一个线程。比如下面这个例子：两个线程调用同一个对象的的方法，一个线程的执行结果会影响另一个线程。

 package com.sky.thread;

 public class TestThreadLocal {
     public static void main(String[] args) {
         final ThreadLocalBiz biz = new ThreadLocalBiz();
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(500);
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                     biz.add();

                 }
             }
         }).start();
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(500);
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                     biz.add();

                 }
             }
         }).start();
     }
 }

 class ThreadLocalBiz {
     private int num = 0;

     public synchronized void add() {
         num++;
         System.out.println("线程：" + Thread.currentThread().getName() + "num:"
                 + num);
     }
 }

线程结果互相影响

执行的结果是：

线程：Thread-0num:1
线程：Thread-1num:2
线程：Thread-0num:3
线程：Thread-1num:4

执行结果

可见，Thread-0执行完以后，num的值是1。当Thread-1开始执行时，num的值对它而言是1而不是一开始的0，所以在Thread-1执行完以后，num的值变成了2。

如果我们想让两个线程在操作同一个共有数据时，互相的操作结果互不影响该怎么办？

这个时候可以使用ThreadLocal。先看下面的代码：

 package com.sky.thread;

 public class TestThreadLocal {

     public static void main(String[] args) {
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(500);
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }

                     ThreadLocalBiz.getBiz().add();

                 }
             }
         }).start();
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }

                     ThreadLocalBiz.getBiz().add();

                 }
             }
         }).start();
     }
 }

 class ThreadLocalBiz {
     private int num = 0;
     public static ThreadLocal<ThreadLocalBiz> LocalBiz = new ThreadLocal<ThreadLocalBiz>();

     private ThreadLocalBiz(){}
     public static ThreadLocalBiz getBiz(){
         ThreadLocalBiz biz = LocalBiz.get();
         if (biz == null) {
             biz = new ThreadLocalBiz();
             LocalBiz.set(biz);
         }
         return biz;
     }
     public void add() {
         num++;
         System.out.println("线程：" + Thread.currentThread().getName() + "，num:"
                 + num);
     }

 }

线程：Thread-0，num:1
线程：Thread-1，num:1
线程：Thread-0，num:2
线程：Thread-0，num:3
线程：Thread-1，num:2

执行结果

这段代码的基本思路是，为不同的线程创建单独的实例。比如上面这段代码，有两个线程调用的ThreadLocalBiz的add方法，那么一共创建的两个ThreadLocalBiz实例。每个线程操作自己的专属实例，自然就不会相互干扰了。

在这段代码中，getBiz和add方法都没有加synchronized，就是因为单个实例只对应单个线程，不存在并发问题，自然也就不用加互斥锁了。

现在来仔细说说ThreadLocal。

ThreadLocal相当于一个Map。以当前线程作为key。

下面的代码

ThreadLocal<ThreadLocalBiz> LocalBiz = new ThreadLocal<ThreadLocalBiz>();
LocalBiz.set(new ThreadLocalBiz());
LocalBiz.get();

就相当于

Map<Thread, ThreadLocalBiz> ThreadMap = new HashMap<Thread, ThreadLocalBiz>();
ThreadMap.put(Thread.currentThread(), new ThreadLocalBiz());
ThreadMap.get(Thread.currentThread());

可见，ThreadLocal完全可以被Map代替。java只是代为封装了一下。