使用 java多线程 ThreadLocal

上学学Java的时候，多线程的安全问题是必讲的，不过ThreadLocal这个概念却没有提及，虽然简单，但还是做个笔记吧。
在Java中，一个变量的作用域有几种：
1. 方法内部的定义的变量：
       被称之为局部变量，仅在当前方法内可访问。
2. private 成员变量：
       只能当前类的所有代码可以访问。
3. protected 成员变量：
       当前类代码或者子类代码可以访问。
4. 没有权限关键字修饰的成员变量：
       当前package下的所有代码可以访问，子类不可以。
5. public 成员变量：
       所有代码中均可访问。
6. static 变量：
       同一个类的所有实例（对象）共享同一个对象引用
7. ThreadLocal 成员变量：
       多个线程之间保存独立的变量（即同一个类，同一个对象可以在不同的线程中拥有线程独立的成员变量。）

小结：
多线程如果共用同一个对象：
1. 如果该对象的成员变量要在线程间共享，则需要使用synchronized关键字适当的进行加锁。
2. 但是如果不共享，则需要使用ThreadLocal对象。

 TestThreadLocal.zip  


MyService.java

package me.test;

public interface MyService {
    String execute();
}

MyThread.java

package me.test;

public class MyThread extends Thread {

    private MyService service = null;

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true) {
            String rtn = service.execute();
            System.out.println("Thread[" + this.getName() + "] :" + rtn);
        }
    }

    public void setService(MyService service) {
        this.service = service;
    }
}

MyServiceImpl1.java

package me.test;

import java.util.Random;

// 这是一个错误的例子
// 示例输出:
//Thread[AAA] :0 -> 1
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :0 -> 2 ERROR
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :2 -> 3
//Thread[AAA] :1 -> 4 ERROR
//Thread[AAA] :4 -> 5
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :3 -> 6 ERROR
//Thread[AAA] :5 -> 7 ERROR
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :6 -> 8 ERROR
//Thread[AAA] :7 -> 9 ERROR
//Thread[AAA] :9 -> 10
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :8 -> 11 ERROR
//Thread[AAA] :10 -> 12 ERROR
//Thread[AAA] :12 -> 13
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :11 -> 14 ERROR
//Thread[AAA] :13 -> 15 ERROR
public class MyServiceImpl1 implements MyService {
    private int num = 0;
    private static Random r = new Random(System.currentTimeMillis());

    @Override
    public String execute() {
        int preVal = num;

        // 用Sleep来代替实际业务中可能会出现的耗时操作，从而更容易发生多线程错误
        int sleepTime = 100 + r.nextInt(900);
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num++;
        return preVal + " -> " + num + (num - preVal != 1 ? " ERROR" : "");
    }

    public static void main(String[] args) {
        MyService service = new MyServiceImpl1();
        MyThread aaa = new MyThread("AAA");
        aaa.setService(service);
        aaa.start();

        MyThread bbb = new MyThread("BBBBBBBBBBBBBBBBBBBBBBBBBB");
        bbb.setService(service);
        bbb.start();
    }
}

MyServiceImpl2.java

package me.test;

import java.util.Random;

// 这是一个正确的例子，
// 变量在线程之间是不共享的
// 每个线程中的num都是从0开始，每次增1。
// 示例输出:
//Thread[AAA] :0 -> 1
//Thread[AAA] :1 -> 2
//Thread[AAA] :2 -> 3
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :0 -> 1
//Thread[AAA] :3 -> 4
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :1 -> 2
//Thread[AAA] :4 -> 5
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :2 -> 3
//Thread[AAA] :5 -> 6
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :3 -> 4
//Thread[AAA] :6 -> 7
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :4 -> 5
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :5 -> 6
//Thread[AAA] :7 -> 8
public class MyServiceImpl2 implements MyService {

    // 使用ThreadLocal
    private ThreadLocal<Integer> num = new ThreadLocal<Integer>();
    private static Random r = new Random(System.currentTimeMillis());

    @Override
    public String execute() {
        if (null == num.get()) {
            num.set(0);
        }
        int preVal = num.get();

        // 用Sleep来代替实际业务中可能会出现的耗时操作，从而更容易发生多线程错误
        int sleepTime = 100 + r.nextInt(900);
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num.set(num.get() + 1);
        return preVal + " -> " + num.get()
                + (num.get() - preVal != 1 ? " ERROR" : "");
    }

    public static void main(String[] args) {
        MyService service = new MyServiceImpl2();
        MyThread aaa = new MyThread("AAA");
        aaa.setService(service);
        aaa.start();

        MyThread bbb = new MyThread("BBBBBBBBBBBBBBBBBBBBBBBBBB");
        bbb.setService(service);
        bbb.start();
    }
}

MyServiceImpl3.java

package me.test;

import java.util.Random;

// 这是一个正确的例子，
// 变量在线程之间是共享的
// 所有线程共建一个自增序列，线程被序列化了（排队），
// 每个线程必须等到队列前面的所有Thread都执行完毕，
// 才能执行被加锁的代码（这里是整个execute()方法）
// 示例输出:
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :0 -> 1
//Thread[AAA] :1 -> 2
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :2 -> 3
//Thread[AAA] :3 -> 4
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :4 -> 5
//Thread[AAA] :5 -> 6
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :6 -> 7
//Thread[AAA] :7 -> 8
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :8 -> 9
//Thread[AAA] :9 -> 10
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :10 -> 11
//Thread[AAA] :11 -> 12
//Thread[BBBBBBBBBBBBBBBBBBBBBBBBBB] :12 -> 13
public class MyServiceImpl3 implements MyService {
    private int num = 0;
    private static Random r = new Random(System.currentTimeMillis());

    // 如果变量在多线程之间确实要共享，则必须使线程同步（synchronized）
    // 这里使用的是方法级别的 synchronize，可以根据业务实际缩小 synchronize 的范围。
    @Override
    public synchronized String execute() {
        int preVal = num;

        // 用Sleep来代替实际业务中可能会出现的耗时操作，从而更容易发生多线程错误
        int sleepTime = 100 + r.nextInt(900);
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num++;
        return preVal + " -> " + num + (num - preVal != 1 ? " ERROR" : "");
    }

    public static void main(String[] args) {
        MyService service = new MyServiceImpl3();
        MyThread aaa = new MyThread("AAA");
        aaa.setService(service);
        aaa.start();

        MyThread bbb = new MyThread("BBBBBBBBBBBBBBBBBBBBBBBBBB");
        bbb.setService(service);
        bbb.start();
    }
}