Java多线程——线程范围内共享变量和ThreadLocal

多个线程访问共享对象和数据的方式

　　1.如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。

package java_thread;
//=================================================
// File Name       :    Runnable_demo2
//------------------------------------------------------------------------------
// Author          :    Commonclass MyThread_2 implements Runnable{private int ticket = 5; @Overridepublic void run() {                               //覆写Thread类中的run()方法// TODO 自动生成的方法存根for (int i=0;i<10;i++){synchronized (this) {                 //设置需要同步的操作if(ticket>0){try{Thread.sleep(300);}catch(InterruptedException e){e.printStackTrace();}System.out.println("卖票：ticket="+ticket--);}}
//          this.sale();                                                //调用同步方法}}//    public synchronized void sale(){            //声明同步方法
//      if(ticket>0){
//          try{
//              Thread.sleep(300);
//          }catch(InterruptedException e){
//              e.printStackTrace();
//          }
//          System.out.println("卖票：ticket="+ticket--);
//      }
//  }}//主类
//Function        :     Thread_demo2
public class Runnable_demo2 {public static void main(String[] args) {// TODO 自动生成的方法存根MyThread_2 mt = new MyThread_2();    //实例化Runnable子类对象Thread t1 = new Thread(mt);                           //实例化Thread类对象Thread t2 = new Thread(mt);                          //实例化Thread类对象Thread t3 = new Thread(mt);                          //实例化Thread类对象t1.start();                                                                   //启动线程t2.start();                                                                   //启动线程t3.start();                                                                   //启动线程}}

　　2.如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：

　　　　方法1：将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。

package java_thread;public class MultiThreadShareData {         //多线程卖票，一个加，一个减//private static ShareData1 data1 = new ShareData1();public static void main(String[] args) {ShareData1 data2 = new ShareData1();new Thread(new MyRunnable1(data2)).start();new Thread(new MyRunnable2(data2)).start();final ShareData1 data1 = new ShareData1();new Thread(new Runnable(){@Overridepublic void run() {data1.decrement();}}).start();new Thread(new Runnable(){@Overridepublic void run() {data1.increment();}}).start();}}class MyRunnable1 implements Runnable{     //线程1private ShareData1 data1;public MyRunnable1(ShareData1 data1){this.data1 = data1;}public void run() {data1.decrement();}}class MyRunnable2 implements Runnable{       //线程2private ShareData1 data1;public MyRunnable2(ShareData1 data1){this.data1 = data1;}public void run() {data1.increment();}}class ShareData1 /*implements Runnable*/{　　//共享对象
/*      private int count = 100;@Overridepublic void run() {// TODO Auto-generated method stubwhile(true){count--;}}*/private int j = 0;public synchronized void increment(){j++;}public synchronized void decrement(){j--;}}

　　　　方法2：将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。

package java_thread;//设计 4 个线程,其中两个线程每次对 j 增加 1,另外两个线程对 j 每次减少 1
public class ThreadTest1{private int j;public static void main(String args[]){ThreadTest1 tt=new ThreadTest1();Inc inc=tt.new Inc();Dec dec=tt.new Dec();for(int i=0;i<2;i++){Thread t=new Thread(inc);t.start();t=new Thread(dec);t.start();}}private synchronized void inc(){j++;System.out.println(Thread.currentThread().getName()+"-inc:"+j);}private synchronized void dec(){j--;System.out.println(Thread.currentThread().getName()+"-dec:"+j);}class Inc implements Runnable{      //线程1public void run(){for(int i=0;i<5;i++){inc();}}}class Dec implements Runnable{       //线程2public void run(){for(int i=0;i<5;i++){dec();}}}}

　　　　上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。

　　　　总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信。

　　3.极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。

package java_thread;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(){@Overridepublic void run() {int data = new Random().nextInt();System.out.println(Thread.currentThread().getName() + " has put data :" + data);threadData.put(Thread.currentThread(), 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().getName() + " get data :" + data);}}static class B{public void get(){int data = threadData.get(Thread.currentThread());          System.out.println("B from " + Thread.currentThread().getName() + " get data :" + data);}        }
}

ThreadLocal实现线程范围的共享变量，ThreadLocal类就相当于一个Map

见下页的示意图和辅助代码解释ThreadLocal的作用和目的：

　　1.用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

　　2.每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

ThreadLocal的应用场景：

　　1、订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。

　　2、银行转账包含一系列操作：把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。

　　3、例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用getContext方法多少次和在哪个模块中getContext方法，拿到的都是同一个。

实验案例：定义一个全局共享的ThreadLocal变量，然后启动多个线程向该ThreadLocal变量中存储一个随机值，接着各个线程调用另外其他多个类的方法，这多个类的方法中读取这个ThreadLocal变量的值，就可以看到多个类在同一个线程中共享同一份数据。

实现对ThreadLocal变量的封装，让外界不要直接操作ThreadLocal变量。

　　对基本类型的数据的封装，这种应用相对很少见。

　　对对象类型的数据的封装，比较常见，即让某个类针对不同线程分别创建一个独立的实例对象。

package java_thread;import java.util.Random;public class ThreadLocalTest {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(){@Overridepublic void run() {int data = new Random().nextInt();System.out.println(Thread.currentThread().getName() + " has put data :" + data);x.set(data);     //存放与当前线程有关的数据new A().get();new B().get();}}).start();}}static class A{public void get(){int data = x.get();System.out.println("A from " + Thread.currentThread().getName() + " get data :" + data);}}static class B{public void get(){int data = x.get();          System.out.println("B from " + Thread.currentThread().getName() + " get data :" + data);     }       }
}

使用ThreadLocal实现在线程范围内共享变量

package java_thread;import java.util.Random;public class ThreadLocalTest {private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();//private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();public static void main(String[] args) {for(int i=0;i<2;i++){new Thread(new Runnable(){@Overridepublic void run() {int data = new Random().nextInt();System.out.println(Thread.currentThread().getName() + " has put data :" + data);x.set(data);              //存放与当前线程有关的数据
/*                  MyThreadScopeData myData = new MyThreadScopeData();myData.setName("name" + data);myData.setAge(data);myThreadScopeData.set(myData);*/MyThreadScopeData.getThreadInstance().setName("name" + data);MyThreadScopeData.getThreadInstance().setAge(data);new A().get();new B().get();}}).start();}}static class A{public void get(){int data = x.get();System.out.println("A from " + Thread.currentThread().getName() + " get data :" + data);
/*          MyThreadScopeData myData = myThreadScopeData.get();;System.out.println("A from " + Thread.currentThread().getName() + " getMyData: " + myData.getName() + "," +myData.getAge());*/MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();System.out.println("A from " + Thread.currentThread().getName() + " getMyData: " + myData.getName() + "," +myData.getAge());}}static class B{public void get(){int data = x.get();          System.out.println("B from " + Thread.currentThread().getName() + " get data :" + data);MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();System.out.println("B from " + Thread.currentThread().getName() + " getMyData: " + myData.getName() + "," +myData.getAge());            }       }
}class MyThreadScopeData{private MyThreadScopeData(){}              //构造方法私有化public static /*synchronized*/ MyThreadScopeData getThreadInstance(){MyThreadScopeData instance = map.get();      //通过map来判断有没有其他线程生成实例对象，如果没有就创建，所以不需要加入synchronizedif(instance == null){instance = new MyThreadScopeData();map.set(instance);}return instance;}//private static MyThreadScopeData instance = null;//new MyThreadScopeData();private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();//把ThreadLocal封装在一个类的内部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多线程——线程范围内共享变量和ThreadLocal相关推荐

【Java系列】（四）Java多线程---线程安全
前言: 记得大一刚学Java的时候,老师带着我们做了一个局域网聊天室,用到了AWT.Socket.多线程.I/O,编写的客户端和服务器,当时做出来很兴奋,回学校给同学们演示,感觉自己好NB,呵呵,扯远 ...
java多线程-线程的停止【interrupt】
java多线程-线程的停止文章目录 java多线程-线程的停止线程停止的原理如何正确停止线程在普通情况下停止线程代码展示在阻塞情况下停止线程代码展示线程在每次迭代后都阻塞代码展示停 ...
Java 多线程线程安全（面试概念解答二）
Java 多线程线程安全什么是线程安全? 为什么有线程安全问题? 线程安全解决办法? 同步代码块同步函数静态同步函数多线程死锁多线程的三大特性原子性可见性有序性 Java内存模型 Vo ...
Java多线程——线程的优先级和生命周期
Java多线程--线程的优先级和生命周期摘要:本文主要介绍了线程的优先级以及线程有哪些生命周期. 部分内容来自以下博客: https://www.cnblogs.com/sunddenly/p/41 ...
java多线程线程安全_Java中的线程安全
java多线程线程安全 Thread Safety in Java is a very important topic. Java provides multi-threaded environme ...
JAVA --- 多线程 -- 线程的创建
JAVA - 多线程 – 线程的创建线程的概念: 说起线程,先说程序和进程,多任务的概念. 程序(program):是指令和数据的有序集合,本身没有任何运行的含义,是一个静态的概念. 进程(proc ...
java多线程-线程创建-线程池-java内存模型
文章目录 ==多线程基础== 进程线程浏览器的进程和线程(案例) 线程的异步和同步多线程的优势 ==多线程的实现方式== 第一种:继承Thread类第二种:实现Runnable接口第三种:通 ...
Java多线程-线程的同步与锁
一.同步问题提出线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏. 例如:两个线程ThreadA.ThreadB都操作同一个对象Foo对象,并修改Foo对象上的数据. package ...
Java多线程 ——线程基础和锁锁锁
Java多线程(一) 一.线程的定义二.Synchronize线程同步三.偏向锁.自旋锁.重量级锁四.volatile关键字 4.1.普通变量运算的物理意义 4.2.有无解决的方案 4.3.vo ...

Java多线程——线程范围内共享变量和ThreadLocal

Java多线程——线程范围内共享变量和ThreadLocal相关推荐

最新文章

热门文章