多线程篇四：ThreadLocal实现线程范围内变量共享
1.static实现线程范围内变量共享
package com.test.shareData; import java.util.Random; /**
* 多线程范围内的数据共享
* @author Administrator
*
*/
public class ThreadScopeShareData { private static int data;
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("currentThread:"+Thread.currentThread().getName()+" get data value is:"+data);
new A().get();
new B().get();
/**
* 输出：static 变量是内存中共享的，第二个线程的值会覆盖第一个线程的值
* currentThread:Thread-0 get data value is:312589459
currentThread:Thread-1 get data value is:312589459
A currentThread:Thread-1 get data value is:312589459
A currentThread:Thread-0 get data value is:312589459
B currentThread:Thread-1 get data value is:312589459
B currentThread:Thread-0 get data value is:312589459
*/
}
}).start();
} } static class A{
public void get(){
System.out.println("A currentThread:"+Thread.currentThread().getName()+" get data value is:"+data);
}
} static class B{
public void get(){
System.out.println("B currentThread:"+Thread.currentThread().getName()+" get data value is:"+data);
}
}
}
currentThread:Thread-0 get data value is:312589459
currentThread:Thread-1 get data value is:312589459
A currentThread:Thread-1 get data value is:312589459
A currentThread:Thread-0 get data value is:312589459
B currentThread:Thread-1 get data value is:312589459
B currentThread:Thread-0 get data value is:312589459
package com.test.shareData; import java.util.Random; /***
* @description 通过ThreadLocal实现，同一个线程范围内，不同的对象中数据共享
* 注意：一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
* 另外：多个变量共享，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
*
*/
public class ThreadLocalTest1 { 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();
x.set(data);
System.out.println(Thread.currentThread().getName()+" data"+data);
MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
myTreadScopeData.setName("chenxiaobing"+data);
myTreadScopeData.setAge(data);
new A().get();
new B().get();
}
}).start();
} }
static class A{
int data=x.get();
private void get(){
System.out.println("class A:"+Thread.currentThread().getName()+data);
MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
System.out.println("class A myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
}
} static class B{
int data=x.get();
private void get(){
System.out.println("class B:"+Thread.currentThread().getName()+data);
MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
System.out.println("class B myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
}
}
} class MyTreadScopeData1{ private MyTreadScopeData1(){}//私有的构成方法，使其他无法创建实例对象 //1.懒汉、饱汉模式的单例，预先定义一个静态的实例对象
/*private static MyTreadScopeData1 instance=new MyTreadScopeData1();
public static MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
return instance;
}*/ //2.饿汉模式的单例，只有在需要时才创建实例对象
/*private static MyTreadScopeData1 instance=null;
public static synchronized MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
if(null==instance){
instance =new MyTreadScopeData1();
}
return instance;
}*/ //3.这里ThreadLocal的使用，类似1/2中的单例模式,只是1/2单例模式，所有线程都会共享MyTreadScopeData1的实例对象
private static ThreadLocal<MyTreadScopeData1> myThreadLocal=new ThreadLocal<MyTreadScopeData1>(); //不同的线程共享不同的实例对象，不需要使用synchronized
public static MyTreadScopeData1 getInstance(){
MyTreadScopeData1 instance=myThreadLocal.get();
if(null==instance){
instance =new MyTreadScopeData1();
myThreadLocal.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;
} }
输出：
currentThread:Thread-1 get data value is:139815514
A currentThread:Thread-1 get map:139815514
currentThread:Thread-0 get data value is:-1291672817
A currentThread:Thread-0 get map:-1291672817
B currentThread:Thread-1 get map:139815514
B currentThread:Thread-0 get map:-1291672817
2.ThreadLocal实现线程范围内变量共享
package com.test.shareData; import java.util.Random; /***
* @description 通过ThreadLocal实现，同一个线程范围内，不同的对象中数据共享
* 注意：一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
* 另外：多个变量共享，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
*
*/
public class ThreadLocalTest { //1.一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
private static ThreadLocal<Integer> x=new ThreadLocal<Integer>(); //2.多个变量共享(共享name,age)，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
private static ThreadLocal<MyTreadScopeData> myThreadLocal=new ThreadLocal<MyTreadScopeData>();
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();
x.set(data);
System.out.println(Thread.currentThread().getName()+" data"+data);
MyTreadScopeData myTreadScopeData=new MyTreadScopeData();
myTreadScopeData.setName("chenxiaobing");
myTreadScopeData.setAge(28);
myThreadLocal.set(myTreadScopeData);
new A().get();
new B().get();
}
}).start();
} }
static class A{
int data=x.get();
private void get(){
System.out.println("class A:"+Thread.currentThread().getName()+data);
// MyTreadScopeData myThread=myThreadLocal.get();
// myThread.setAge(30);
// myThread.setName("aaaaaaaaaaaaaaa");
System.out.println("class A myThreadLocal:"+Thread.currentThread().getName()+myThreadLocal.get().getName());
}
} static class B{
int data=x.get();
private void get(){
System.out.println("class B:"+Thread.currentThread().getName()+data);
// MyTreadScopeData myThread=myThreadLocal.get();
// myThread.setAge(30);
// myThread.setName("bbbbbbbbbbbbbbbb");
System.out.println("class B myThreadLocal:"+Thread.currentThread().getName()+myThreadLocal.get().getName()); }
}
} class MyTreadScopeData{
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;
} }
输出：
Thread-0 data1679550355
Thread-1 data387829581
class A:Thread-1387829581
class A myThreadLocal:Thread-1chenxiaobing
class B:Thread-1387829581
class B myThreadLocal:Thread-1chenxiaobing
class A:Thread-01679550355
class A myThreadLocal:Thread-0chenxiaobing
class B:Thread-01679550355
class B myThreadLocal:Thread-0chenxiaobing
单例模式：
package com.test.shareData; import java.util.Random; /***
* @description 通过ThreadLocal实现，同一个线程范围内，不同的对象中数据共享
* 注意：一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
* 另外：多个变量共享，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
*
*/
public class ThreadLocalTest1 { 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();
x.set(data);
System.out.println(Thread.currentThread().getName()+" data"+data);
MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
myTreadScopeData.setName("chenxiaobing"+data);
myTreadScopeData.setAge(data);
new A().get();
new B().get();
}
}).start();
} }
static class A{
int data=x.get();
private void get(){
System.out.println("class A:"+Thread.currentThread().getName()+data);
MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
System.out.println("class A myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
}
} static class B{
int data=x.get();
private void get(){
System.out.println("class B:"+Thread.currentThread().getName()+data);
MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
System.out.println("class B myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
}
}
} class MyTreadScopeData1{ private MyTreadScopeData1(){}//私有的构成方法，使其他无法创建实例对象 //1.懒汉、饱汉模式的单例，预先定义一个静态的实例对象
/*private static MyTreadScopeData1 instance=new MyTreadScopeData1();
public static MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
return instance;
}*/ //2.饿汉模式的单例，只有在需要时才创建实例对象
/*private static MyTreadScopeData1 instance=null;
public static synchronized MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
if(null==instance){
instance =new MyTreadScopeData1();
}
return instance;
}*/ //3.这里ThreadLocal的使用，类似1/2中的单例模式,只是1/2单例模式，所有线程都会共享MyTreadScopeData1的实例对象
private static ThreadLocal<MyTreadScopeData1> myThreadLocal=new ThreadLocal<MyTreadScopeData1>(); //不同的线程共享不同的实例对象，不需要使用synchronized
public static MyTreadScopeData1 getInstance(){
MyTreadScopeData1 instance=myThreadLocal.get();
if(null==instance){
instance =new MyTreadScopeData1();
myThreadLocal.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;
} }
输出：
Thread-0 data667513514
class A:Thread-0667513514
class A myThreadLocal:Thread-0chenxiaobing667513514
Thread-1 data-452485471
class A:Thread-1-452485471
class A myThreadLocal:Thread-1chenxiaobing-452485471
class B:Thread-0667513514
class B:Thread-1-452485471
class B myThreadLocal:Thread-1chenxiaobing-452485471
class B myThreadLocal:Thread-0chenxiaobing667513514
多线程篇四：ThreadLocal实现线程范围内变量共享的更多相关文章
- 多线程（四） 实现线程范围内模块之间共享数据及线程间数据独立（Map集合）
多个线程访问共享对象和数据的方式 1.如果每个线程执行的代码相同,可以使用同一个Runnable对象,这个Runnable对象中有那个共享数据,例如,买票系统就可以这么做. 2.如果每个线程执行的代码 ...
- 多线程（三） 实现线程范围内模块之间共享数据及线程间数据独立（ThreadLocal）
ThreadLocal为解决多线程程序的并发问题提供了一种新的思路.JDK 1.2的版本中就提供java.lang.ThreadLocal,使用这个工具类可以很简洁地编写出优美的多线程程序,Threa ...
- ThreadLocal实现线程范围内共享
线程范围内共享,即是对相同一段代码,在不同的模块调用时使用一份数据,而在另外一个线程中又使用另外一份数据. ThreadLocal使用set方法为一个新的线程增加一条记录,key是各自的线程,valu ...
- 线程：ThreadLocal实现线程范围内共享变量
在web应用中,一个请求(带有请求参数)就是一个线程,那么如何区分哪些参数属于哪个线程呢?比如struts中,A用户登录,B用户也登录,那么在Action中怎么区分哪个是A用户的数据,哪个是B用户的数 ...
- 线程系列4--Java线程范围内的共享数据（一）
这张图片是我看传智播客的视频时的截屏,这个图片很直观的展示了线程范围内的数据共享.当同一个线程在执行三个不同业务模块时,这三个业务模块访问的数据是共享的.更直白的说,当一个执行线索在穿个每个业务模块时 ...
- java多线程与线程并发四：线程范围内的共享数据
当多个线程操作同一个共有数据时,一个线程对共有数据的改变会影响到另一个线程.比如下面这个例子:两个线程调用同一个对象的的方法,一个线程的执行结果会影响另一个线程. package com.sky.th ...
- （Java多线程系列四）停止线程
停止线程 停止线程的思路 ①使用退出标志,使线程正常退出,也就是当run()方法结束后线程终止. class Thread01 extends Thread { // volatile关键字解决线程的 ...
- 【Java多线程系列四】控制线程执行顺序
假设有线程1/线程2/线程3,线程3必须在线程1/线程2执行完成之后开始执行,有两种方式可实现 Thread类的join方法:使宿主线程阻塞指定时间或者直到寄生线程执行完毕 CountDownLatc ...
- ThreadLocal实现线程范围的共享变量
一.如何理解线程范围内共享数据 1.static int num=0; 2.线程1访问num变量,并设置为num=2:线程2访问num变量,并设置为num=3: 3.当线程1中对象A.B.C 在访问线 ...
随机推荐
- HDU6318-2018ACM暑假多校联合训练2-1010-Swaps and Inversions-树状数组
本题题意是,给你一个长度为n的序列,使用最少的操作把序列转换为从小到大的顺序,并输出操作数*min(x,y) 实质上是算出该序列中有多少逆序对,有归并排序和树状数组两种算法,由于数据之间的差值有点大, ...
- logback&slf4j学习笔记
1.Slf4j 1.1.Slf4j简介 SLF4J,即简单日志门面(Simple Logging Facade for Java),不是具体的日志解决方案,它只服务于各种各样的日志系统.实际上,SLF ...
- Tensorflow可视化MNIST手写数字训练
简述] 我们在学习编程语言时,往往第一个程序就是打印“Hello World”,那么对于人工智能学习系统平台来说,他的“Hello World”小程序就是MNIST手写数字训练了.MNIST是一个手写 ...
- 洛谷 P1579 哥德巴赫猜想（升级版）
嗯... 这或许也算一道数论题吧... 题目链接:https://www.luogu.org/problemnew/show/P1579 这道题的说明好像只会扰乱人的思路....然后就是这道题的细节比 ...
- 50行代码实现python计算器主要功能
实现功能:计算带有括号和四则运算的式子 3*( 4+ 50 )-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4) 基本思路:使用正则表达式提取出每一层 ...
- Linux下parted分区超过2TB硬盘-分区格式化
1.parted 设备名进入分区 parted /dev/vdb 2.输入print打印列出当前分区设备的磁盘容量大小 3.设置磁盘分区为gpt模 mklabel gpt 然后点击YES继续(提示磁盘 ...
- HDU_6298 Maximum Multiple 【找规律】
一.题目 Given an integer $n$, Chiaki would like to find three positive integers $x$, $y$ and $z$ such t ...
- Bound Found(思维+尺取)
Signals of most probably extra-terrestrial origin have been received and digitalized by The Aeronaut ...
- BZOJ - 4520 K远点对
题意:已知平面内 N 个点的坐标,求欧氏距离下的第 K 远点对 维护大小为2k最小堆,KD树的估值用前面提到的做法 PS.网上有人估价是使用边界四个点的最值来独立枚举,然而这样写似乎过不了 #incl ...
- Codeforces - 570D 离散DFS序 特殊的子树统计 (暴力出奇迹)
题意:给定一棵树,树上每个节点有对应的字符,多次询问在\(u\)子树的深度为\(d\)的所有节点上的字符任意组合能否凑成一个回文串 把dfs序存储在一个二维线性表中,一个维度记录字符另一个维度记录深度 ...