线程范围内的数据共享

• 要实现线程范围内的数据共享，不管是A模块还是B模块，还是主线程模块，如果它们在第一个线程上运行，它们操作的线程必须是同一个。
  

• 首先先看一下非线程范围内的数据共享：
  代码如下：

package com.java;

import java.util.Random;

public class ThreadScopeShareData {

    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()
                            + "has put data of" + data); // 用于打印一句话
                    new A().get();// 调用A的get方法
                    new B().get();// 调用B的get方法
                }
            }).start();
        }
    }

    static class A { // A模块
        public void get() { // 用于接收数据
            System.out.println("A :" + Thread.currentThread().getName()
                    + "get data of" + data);
        }
    }

    static class B { // B模块
        public void get() { // 用于接收数据
            System.out.println("B :" + Thread.currentThread().getName()
                    + "get data of" + data);
        }

    }
}

• 运行后的结果，不管它们在哪一个线程上运行，它们访问的都是同一份。

• 如何让它们显示各自独立的效果？

将每个线程用到的数据与对应的线程号存放到一个map集合中，使用数据时从这个集合中根据线程号获取对应线程的数据

代码如下：

package com.java;

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

public class ThreadScopeShareData {

    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() {
                int data = new Random().nextInt();// 定义一个数据
                    System.out.println(Thread.currentThread().getName()
                            + "has put data of" + data); // 用于打印一句话
                    threadData.put(Thread.currentThread(), data);  //用于放当前正在执行代码的线程，和它的数据
                    new A().get();// 调用A的get方法
                    new B().get();// 调用B的get方法
                }
            }).start();
        }
    }

    static class A { // A模块
        public void get() { // 用于接收数据
            int data = threadData.get(Thread.currentThread());  //当前的数据

            System.out.println("A :" + Thread.currentThread().getName()   //取出当前的数据
                    + "get data of" + data);
        }
    }

    static class B { // B模块
        public void get() { // 用于接收数据
            int data = threadData.get(Thread.currentThread());   //当前的数据

            System.out.println("B :" + Thread.currentThread().getName()
                    + "get data of" + data);
        }

    }
}

改进：——>

• jdk提供了一个ThreadLocal类，用于实现线程范围内的共享变量，这个ThreadLocal 类相当于一个Map。

• ThreadLocal的作用和目的：用于实现线程范围内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另一个线程中运行时又共享另外一份数据。

• 每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。

private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {

            new Thread(new Runnable() {

                @Override
                public void run() {
                int data = new Random().nextInt();// 定义一个数据
                    System.out.println(Thread.currentThread().getName()
                            + "has put data of" + data); // 用于打印一句话
                    x.set(data);   //调用对象x的set()方法
                    new A().get();// 调用A的get方法
                    new B().get();// 调用B的get方法
                }
            }).start();
        }
    }

    static class A { // A模块
        public void get() { // 用于接收数据
            int data = x.get();   //得到当前对象的值
            System.out.println("A :" + Thread.currentThread().getName()   //取出当前的数据
                    + "get data of" + data);
        }
    }

    static class B { // B模块
        public void get() { // 用于接收数据
            int data = x.get();    //得到当前对象的值
            System.out.println("B :" + Thread.currentThread().getName()
                    + "get data of" + data);
        }

    }

---

n个变量都是线程范围内的共享

一个ThreadLocal对象只能记录一个线程内部的共享变量，若要记录多个共享数据，需将数据封装起来，将封装的对象存入ThreadLocal对象中。

将数据对象封装成单例，同时提供线程范围内的共享数据的设置和获取方法，提供已经封装好了的线程范围内的对象实例，使用时只需获取实例对象即可实现数据的线程范围内的共享。

以下代码：

package com.lfeifei;

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

public class ThreadBing {
    private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
    private static ThreadLocal<MyThread> myThread = new ThreadLocal<MyThread>();

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

                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName()
                            + "has put data" + data);
                    x.set(data);
                    /*MyThread myData = new MyThread();
                    myData.setName("name" + data);
                    myData.setAge(data);*/
                    MyThread.getInstance().setName("name" + data);
                    MyThread.getInstance().setAge(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            int data = x.get();
            System.out.println("A form" + Thread.currentThread().getName()
                    + "get data" + data);
            MyThread myData = MyThread.getInstance();
            System.out.println("A form" + Thread.currentThread().getName()
                    + "getMyData" + myData.getName() + "," + myData.getAge());
        }
    }

    static class B {
        public void get() {
            int data = x.get();
            System.out.println("B form" + Thread.currentThread().getName()
                    + "get data" + data);
            MyThread myData = MyThread.getInstance();
            System.out.println("B form" + Thread.currentThread().getName()
                    + "getMyData" + myData.getName() + "," + myData.getAge());
        }
    }
}

class MyThread {


    public static MyThread getInstance() {   //单例
        MyThread instance = map.get();
        if (instance == null) {
            instance = new MyThread();
            map.set(instance);
        }
        return instance;
    }

//  private static MyThread instance = null;
    private static ThreadLocal<MyThread> map = new ThreadLocal<MyThread>();

    private String name;
    private int age;

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

---

注：此系列博客参照张孝祥的java并发视频，以及java高并发程序等书写的，因为本人小白正在努力学习中，对知识掌握的特别的肤浅，如果看到我的博文，有什么不对的地方，或者是对我文章有意见的，可以私信给我，我会一直不断改进的。