多线程05-线程范围内共享变量

时间：2014-06-15 07:11:25 阅读：418 评论：0 收藏：0 [点我收藏+]

1.问题引入

多个业务模块针对同一个static变量的操作要保证在不同线程中各模块操作的是自身对应的变量对象

例如：


package org.lkl.thead;

import java.util.Random;

/**
 * 线程共享数据
 * Function : 
 * @author : Liaokailin
 * CreateDate : 2014-6-12
 * version : 1.0
 */
public class ThreadShareData {

    private static  int data = 0 ;
    
    public static void main(String[] args) {
      for(int i = 0 ;i<2 ;i++){
        new Thread(new Runnable(){

            @Override
            public void run() {
                data = new Random().nextInt();
                System.out.println(Thread.currentThread().getName()+ " put random data:"+data);
                new A().get() ;
                new B().get() ;
            }
            
        }).start() ;
      }
        
    }
    
    static class A {
        public int get(){
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " get data :" + data);
            return data ;
        }
    }
    
    static class B{
        public int get(){
            System.out.println("B from " + Thread.currentThread().getName() 
                    + " get data :" + data);
            return data ;
        }
    }
}

　　模块A ，B都需要访问static的变量data 在线程0中会随机生成一个data值假设为10 那么此时模块A和模块B在线程0中得到的data的值为10 ；在线程1中假设会为data赋值为20 那么在当前线程下

模块A和模块B得到data的值应该为20

看程序执行的结果：

Thread-0 put random data:-1344602819
Thread-1 put random data:-1842611697
A from Thread-1 get data :-1842611697
A from Thread-0 get data :-1842611697
B from Thread-1 get data :-1842611697
B from Thread-0 get data :-1842611697

在线程0中执行模块A和模块B的方法去获取data的值但是在获取之前线程1就将data的值给修改为-1842611697 导致线程0中的模块A和模块B获取了错误的数据.

2.解决问题

那么如何得到正确的效果呢？

可是将data数据和当前允许的线程绑定在一块，在模块A和模块B去获取数据data的时候是通过当前所属的线程去取得data的结果就行了。

声明一个Map集合集合的Key为Thread 存储当前所属线程 Value 保存data的值，代码如下：

package org.lkl.thead.sharedata;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * 线程共享数据
 * Function : 
 * @author : Liaokailin
 * CreateDate : 2014-6-12
 * version : 1.0
 */
public class ThreadShareData {

    private static  int data = 0 ;
    private static Map<Thread,Integer> threadData = new HashMap<Thread, Integer>() ;
    
    public static void main(String[] args) {
      for(int i = 0 ;i<2 ;i++){
        new Thread(new Runnable(){

            @Override
            public  void run() {
                synchronized (ThreadShareData.class) {  //保证下面的代码都执行完才允许其他线程进入
                    data = new Random().nextInt();
                    threadData.put(Thread.currentThread(), data) ; //将数据绑定到带当前线程
                    System.out.println(Thread.currentThread().getName()+ " put random data:"+data);
                    new A().get() ;
                    new B().get() ;
                }
            }
            
        }).start() ;
      }
        
    }
    
    static class A {
        public int get(){
            //取数据都从当前线程中取得 
            int d = threadData.get(Thread.currentThread()) ;
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " get data :" + d);
            return data ;
        }
    }
    
    static class B{
        public int get(){
            //取数据都从当前线程中取得 
            int d  = threadData.get(Thread.currentThread()) ;
            System.out.println("B from " + Thread.currentThread().getName() 
                    + " get data :" + d);
            return data ;
        }
    }
}

程序执行的结果：

Thread-0 put random data:-1842492021
A from Thread-0 get data :-1842492021
B from Thread-0 get data :-1842492021
Thread-1 put random data:-1886142929
A from Thread-1 get data :-1886142929
B from Thread-1 get data :-1886142929

3 问题的拓展

将数据与当前线程相挂钩的话那么显然是可以利用ThreadLocal这个类那么改造上面的代码得到下面的代码：

package org.lkl.thead.sharedata;

import java.util.Random;

/**
 * 线程共享数据
 * Function : 
 * @author : Liaokailin
 * CreateDate : 2014-6-12
 * version : 1.0
 */
public class ThreadShareData {

    private static  int data = 0 ;
    /**
     * ThreadLocal 类似于map集合 只是集合的key是当前正在运行的线程  
     * 通过ThreadLocal可以将变量（或者是变量的容器）与当前线程相绑定.
     */
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() ;
    
    
    public static void main(String[] args) {
      for(int i = 0 ;i<2 ;i++){
        new Thread(new Runnable(){

            @Override
            public  void run() {
                synchronized (ThreadShareData.class) {  //保证下面的代码都执行完才允许其他线程进入
                    data = new Random().nextInt();
                    threadLocal.set(data) ; //将数据绑定到带当前线程
                    System.out.println(Thread.currentThread().getName()+ " put random data:"+data);
                    new A().get() ;
                    new B().get() ;
                }
            }
            
        }).start() ;
      }
        
    }
    
    static class A {
        public int get(){
            //取数据都从当前线程中取得 
            int d = threadLocal.get() ;
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " get data :" + d);
            return data ;
        }
    }
    
    static class B{
        public int get(){
            //取数据都从当前线程中取得 
            int d = threadLocal.get() ;
            System.out.println("B from " + Thread.currentThread().getName() 
                    + " get data :" + d);
            return data ;
        }
    }
}

代码执行完以后会得到同样的效果。

接下来还有一个问题上面一直讨论的是线程间共享一个变量那么如果是多个变量呢？

要直接ThreadLocal每次只能是一个变量和当前线程挂钩如果有多个变量要和当前线程挂钩的话就得生命多个ThreadLocal对象这样子做很显然是不合理的。那如何处理呢？

由于ThreadLocal可以并且只能和一个变量挂钩，那么我们可以将这个变量设置为一个变量的容器，容器中可以存在多个变量，这也就是将需要和当前线程绑定的变量封装到一个实体类中

package org.lkl.thead.sharedata;

import java.util.Random;

/**
 * 线程共享数据
 * Function : 
 * @author : Liaokailin
 * CreateDate : 2014-6-12
 * version : 1.0
 */
public class ThreadShareData {

    private static  int data = 0 ;
    
    public static void main(String[] args) {
      for(int i = 0 ;i<2 ;i++){
        new Thread(new Runnable(){

            @Override
            public  void run() {
                synchronized (ThreadShareData.class) {  //保证下面的代码都执行完才允许其他线程进入
                    data = new Random().nextInt();
                    VariableContainer.getThreadInstance().setAge(data) ;
                    VariableContainer.getThreadInstance().setName("liaokailin-"+data) ; 
                    System.out.println(Thread.currentThread().getName()+ " Put  VariableContainer:"+VariableContainer.getThreadInstance().toString());
                    new A().get() ;
                    new B().get() ;
                }
            }
            
        }).start() ;
      }
        
    }
    
    static class A {
        public int get(){
            //取数据都从当前线程中取得 
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " get data :" + VariableContainer.getThreadInstance().toString());
            return data ;
        }
    }
    
    static class B{
        public int get(){
            //取数据都从当前线程中取得 
             
            System.out.println("B from " + Thread.currentThread().getName() 
                    + " get data :" + VariableContainer.getThreadInstance().toString());
            return data ;
        }
    }
    
}


/**
 * 变量容器
 */
class VariableContainer{
    private String name ;
    private int age ;
    private static  ThreadLocal<VariableContainer> threadLocal = new ThreadLocal<VariableContainer>() ;
    /**
     * 获取当前线程中绑定的变量容器   外部可以往容器中设值
     */
    public static VariableContainer  getThreadInstance(){
        VariableContainer container = threadLocal.get() ;
        if(container==null){
            container = new VariableContainer() ;
            threadLocal.set(container) ;
        }
        return container ;
        
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "VariableContainer [name=" + name + ", age=" + age + "]";
    }
    
    
    
}

执行结果：

Thread-0 Put  VariableContainer:VariableContainer [name=liaokailin--2103275506, age=-2103275506]
A from Thread-0 get data :VariableContainer [name=liaokailin--2103275506, age=-2103275506]
B from Thread-0 get data :VariableContainer [name=liaokailin--2103275506, age=-2103275506]
Thread-1 Put  VariableContainer:VariableContainer [name=liaokailin-816504398, age=816504398]
A from Thread-1 get data :VariableContainer [name=liaokailin-816504398, age=816504398]
B from Thread-1 get data :VariableContainer [name=liaokailin-816504398, age=816504398]

多线程05-线程范围内共享变量,布布扣,bubuko.com

多线程05-线程范围内共享变量

原文：http://www.cnblogs.com/liaokailin/p/3785958.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)