java基础多线程之共享数据

java基础巩固笔记5-多线程之共享数据

线程范围内共享数据

threadlocal类

多线程访问共享数据

几种方式

本文主要总结线程共享数据的相关知识，主要包括两方面:一是某个线程内如何共享数据，保证各个线程的数据不交叉；一是多个线程间如何共享数据，保证数据的一致性。

自己实现的话，是定义一个map,线程为键，数据为值,表中的每一项即是为每个线程准备的数据,这样在一个线程中数据是一致的。

例子

package com.iot.thread;

import java.util.hashmap;

import java.util.map;

import java.util.random;

/**

 * created by brian on 2016/2/4.

 */

public class threadscopesharedata {

    //准备一个哈希表，为每个线程准备数据

    private  static map<thread,integer> threaddata = new hashmap<>();

    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();

                    threaddata.put(thread.currentthread(),data);

                    system.out.println(thread.currentthread()+" put data："+data);

                    new a().get();

                    new b().get();

                }

            }).start();

        }

    }

   static  class a{

        public void get(){

            int data = threaddata.get(thread.currentthread());

            system.out.println("a from "+thread.currentthread()+" get data "+data);

    static  class b{

            system.out.println("b from "+thread.currentthread()+" get data "+data);

}

上述代码偶尔会报异常：

exception in thread "thread-0" java.lang.nullpointerexception

    at com.iot.thread.threadscopesharedata$a.get(threadscopesharedata.java:29)

    at com.iot.thread.threadscopesharedata$1.run(threadscopesharedata.java:21)

    at java.lang.thread.run(thread.java:745)

1

2

3

4

5

具体原因还不知道

api:

java.lang:class threadlocal<t>

单变量

使用threadlocal类型的对象代替上面的map即可

多变量

定义一个对象来封装多个变量，然后在threadlocal中存储整个对象

多变量时，最好将threadlocal类放在数据类的内部，数据类采用单例模式，这样，新建对象和获取对象都会更方便，同时封装性更强。

示例代码:

public class threadlocaltest {

    private  static threadlocal<integer> threadinger = new threadlocal<>();

            new thread(new runnable() {

                    int data = new random().nextint(100);

                    threadinger.set(data);

                    mythreadscopedata.getthreadinstance().setname(thread.currentthread().tostring());

                    mythreadscopedata.getthreadinstance().setage(data%10);

    static  class a{

            int data = threadinger.get();

            mythreadscopedata mythreadscopedata = mythreadscopedata.getthreadinstance();

            system.out.println("a from "+mythreadscopedata);

            system.out.println("b from "+mythreadscopedata);

 * 将多变量封装起来的数据类

 * 单例模式，内置threadlocal类型变量

class mythreadscopedata{

    private mythreadscopedata(){}

    private static threadlocal<mythreadscopedata> data = new threadlocal<>();

    public static  mythreadscopedata getthreadinstance(){

        mythreadscopedata instance = data.get();

        if(instance == null){

            instance = new mythreadscopedata();

            data.set(instance);

        return instance;

    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;

    @override

    public string tostring() {

        string reval = super.tostring()+"-{name,age}"+":{"+getname()+","+getage()+"}";

        return reval;

线程执行代码相同，使用同一runnable对象，runnable对象中有共享数据

线程执行代码不同，将共享数据封装在另一对象中（操作数据的方法也在该对象完成），将这个对象逐一传递给各个runnable对象。[本质：共享数据的对象作为参数传入runnable对象]

线程执行代码不同，将runnable对象作为某一个类的内部类，共享数据作为这个外部类的成员变量（操作数据的方法放在外部类）。[本质:不同内部类共享外部类数据]

结合上两种方式，将共享数据封装在另一对象中（操作数据的方法也在该对象完成），该对象作为这个外部类的成员变量，将runnable对象作为内部类

最后一种方式的示例:

设计5个线程，其中三个线程每次对j增加1，另外两个线程对j每次减少1

public class mutithreadsharedata {

    private static mutisharedata mutisharedata = new mutisharedata();

        for(int i=0;i<3;i++){

                        @override

                        public void run() {

                            system.out.println(thread.currentthread()+":{j from "+ mutisharedata.getj()+" + to: "+mutisharedata.increment()+"}");

                        }

                    }

            ).start();

                            system.out.println(thread.currentthread()+":{j from "+ mutisharedata.getj()+" - to: "+mutisharedata.decrement()+"}");

 * 将共享数据封装在另一对象中（操作数据的方法也在该对象完成）

class mutisharedata{

    private int j = 0;

    public synchronized  int increment(){

        return  ++j;

    public synchronized int  decrement(){

        return --j;

    public synchronized int getj() {

        return j;

    public synchronized void setj(int j) {

        this.j = j;