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只是代为封装了一下。