多线程篇四：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 在访问线 ...
随机推荐
- select展开时 重新加载 option,ie 折叠问题 以及 chrome 没有变化问题
这个bug是因为浏览器的渲染问题引起的 一:重新加载option的渲染处理 1:火狐能重新渲染,并且select不折叠 2:ie重新渲染,但是select收缩折叠 3:chrome直接不重新进行渲染, ...
- 命令行里打 cd 简直是浪费生命
简评:作为工程师,你在命令行下最常打的命令无非就是 cd 与 ls.这些年你浪费了多少时间? 作为一个程序员或者在 shell 中花费大量时间的人,你可能会经常以一种低效率的方式在目录中来回移动,特别 ...
- 解决Nginx+PHP-FPM出现502（Bad Gateway）错误问题
Bad Gateway就是性能或资源不足所导致了,我们浏览网页时常常会碰到一些nginx环境出现这类提醒了,下面我来给大家解决在使用nginx服务器时出来的502(Bad Gateway)错误. 买了 ...
- 品味ZooKeeper之纵古观今_1
品味ZooKeeper之纵古观今 本章思维导图 这一系列主要是从整体到细节来品味Zookeeper,先从宏观来展开,介绍zookeeper诞生的原因,接着介绍整体设计框架,接着是逐个细节击破. 本章是 ...
- fork（）父子进程文件描述符的关系
父子进程共享文件描述符:此说法,其实是父子进程共享 文件表项(父进程和子进程共享同一个file table entry) 由于子进程是父进程的拷贝,子进程会拷贝父进程的进程描述符中的文件描述符表,可以 ...
- jenkins安装maven工具
下载maven工具,然后解压到/usr/local下面 然后在jenkins上面添加maven工具.指定他的设置配置文件(全局) 指定maven的目录位置 应用保存即可 !!! 虽然maven安装简单 ...
- OEL6.8安装虚拟带库模拟器
最近在虚拟机下搭建了一个OSB备份环境,其中使用到了虚拟带库,以下是虚拟带库的配置过程,简要记录之. 1.下载虚拟带库的源码(mhvtl-2016-03-10.tgz). 2.解压缩源码. # cd ...
- BCH code
简单介绍 若循环码的生成多项式具有如下形式\(g(x)=LCM[m_{1}(x),m_{3}(x)..m_{2t-1}(x)]\) 其中LCM表示最小公倍式,t为纠错个数,\(m_{i}(x)\)为素 ...
- python---day14（ 内置函数二）
内置函数二一:匿名函数 lambda函数 lambda 表示匿名函数,不需要用def 来申明. 语法: 函数名=lambda 参数:返回值 ----〉 案例:f=lambda n:n*n 例子01: ...
- 利用Python将文件进行分类整理
利用Python将文件进行分类整理 功能 根据一个文件夹中的文件类型建立相应的文件夹,将同一种类型的文件放在一个文件夹中. 实现思路 主要用到 os 和 shutil 两个库,os 用来获取文件夹中的 ...