1.static实现线程范围内变量共享

  1. package com.test.shareData;
  2.  
  3. import java.util.Random;
  4.  
  5. /**
  6.  * 多线程范围内的数据共享
  7.  * @author Administrator
  8.  *
  9.  */
  10. public class ThreadScopeShareData {
  11.  
  12.     private static int data;
  13.     public static void main(String[] args) {
  14.         for(int i=0;i<2;i++){
  15.             new Thread(new Runnable(){
  16.                 @Override
  17.                 public void run() {
  18.                     data=new Random().nextInt();
  19.                     System.out.println("currentThread:"+Thread.currentThread().getName()+" get data value is:"+data);
  20.                     new A().get();
  21.                     new B().get();
  22.                     /**
  23.                      * 输出：static 变量是内存中共享的，第二个线程的值会覆盖第一个线程的值
  24.                      *  currentThread:Thread-0 get data value is:312589459
  25.                         currentThread:Thread-1 get data value is:312589459
  26.                         A currentThread:Thread-1 get data value is:312589459
  27.                         A currentThread:Thread-0 get data value is:312589459
  28.                         B currentThread:Thread-1 get data value is:312589459
  29.                         B currentThread:Thread-0 get data value is:312589459
  30.                      */
  31.                 }
  32.             }).start();
  33.         }
  34.  
  35.     }
  36.  
  37.     static class A{
  38.         public void get(){
  39.             System.out.println("A currentThread:"+Thread.currentThread().getName()+" get data value is:"+data);
  40.         }
  41.     }
  42.  
  43.     static class B{
  44.         public void get(){
  45.             System.out.println("B currentThread:"+Thread.currentThread().getName()+" get data value is:"+data);
  46.         }
  47.     }
  48. }

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

  1. package com.test.shareData;
  2.  
  3. import java.util.Random;
  4.  
  5. /***
  6.  * @description 通过ThreadLocal实现，同一个线程范围内，不同的对象中数据共享
  7.  * 注意：一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
  8.  * 另外：多个变量共享，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
  9.  *
  10.  */
  11. public class ThreadLocalTest1 {
  12.  
  13.     private static ThreadLocal<Integer> x=new ThreadLocal<Integer>();
  14.     public static void main(String[] args) {
  15.         for(int i=0;i<2;i++){
  16.             new Thread(new Runnable(){
  17.                 @Override
  18.                 public void run() {
  19.                     int data=new Random().nextInt();
  20.                     x.set(data);
  21.                     System.out.println(Thread.currentThread().getName()+" data"+data);
  22.                     MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
  23.                     myTreadScopeData.setName("chenxiaobing"+data);
  24.                     myTreadScopeData.setAge(data);
  25.                     new A().get();
  26.                     new B().get();
  27.                 }
  28.             }).start();
  29.         }
  30.  
  31.     }
  32.     static class A{
  33.         int data=x.get();
  34.         private void get(){
  35.             System.out.println("class A:"+Thread.currentThread().getName()+data);
  36.             MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
  37.             System.out.println("class A  myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
  38.         }
  39.     }
  40.  
  41.     static class B{
  42.         int data=x.get();
  43.         private void get(){
  44.             System.out.println("class B:"+Thread.currentThread().getName()+data);
  45.             MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
  46.             System.out.println("class B  myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
  47.         }
  48.     }
  49. }
  50.  
  51. class MyTreadScopeData1{
  52.  
  53.     private MyTreadScopeData1(){}//私有的构成方法，使其他无法创建实例对象
  54.  
  55.     //1.懒汉、饱汉模式的单例，预先定义一个静态的实例对象
  56.     /*private static MyTreadScopeData1 instance=new MyTreadScopeData1();
  57.     public static MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
  58.         return instance;
  59.     }*/
  60.  
  61.     //2.饿汉模式的单例，只有在需要时才创建实例对象
  62.     /*private static MyTreadScopeData1 instance=null;
  63.     public static synchronized MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
  64.         if(null==instance){
  65.             instance =new MyTreadScopeData1();
  66.         }
  67.         return instance;
  68.     }*/
  69.  
  70.     //3.这里ThreadLocal的使用，类似1/2中的单例模式,只是1/2单例模式，所有线程都会共享MyTreadScopeData1的实例对象
  71.     private static ThreadLocal<MyTreadScopeData1> myThreadLocal=new ThreadLocal<MyTreadScopeData1>();
  72.  
  73.     //不同的线程共享不同的实例对象，不需要使用synchronized
  74.     public static MyTreadScopeData1 getInstance(){
  75.         MyTreadScopeData1 instance=myThreadLocal.get();
  76.         if(null==instance){
  77.             instance =new MyTreadScopeData1();
  78.             myThreadLocal.set(instance);
  79.         }
  80.         return instance;
  81.     }
  82.  
  83.     private String name;
  84.     private int age;
  85.     public String getName() {
  86.         return name;
  87.     }
  88.     public void setName(String name) {
  89.         this.name = name;
  90.     }
  91.     public int getAge() {
  92.         return age;
  93.     }
  94.     public void setAge(int age) {
  95.         this.age = age;
  96.     }
  97.  
  98. }

输出：

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实现线程范围内变量共享

  1. package com.test.shareData;
  2.  
  3. import java.util.Random;
  4.  
  5. /***
  6.  * @description 通过ThreadLocal实现，同一个线程范围内，不同的对象中数据共享
  7.  * 注意：一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
  8.  * 另外：多个变量共享，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
  9.  *
  10.  */
  11. public class ThreadLocalTest {
  12.  
  13.     //1.一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
  14.     private static ThreadLocal<Integer> x=new ThreadLocal<Integer>();
  15.  
  16.     //2.多个变量共享(共享name,age)，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
  17.     private static ThreadLocal<MyTreadScopeData> myThreadLocal=new ThreadLocal<MyTreadScopeData>();
  18.     public static void main(String[] args) {
  19.         for(int i=0;i<2;i++){
  20.             new Thread(new Runnable(){
  21.                 @Override
  22.                 public void run() {
  23.                     int data=new Random().nextInt();
  24.                     x.set(data);
  25.                     System.out.println(Thread.currentThread().getName()+" data"+data);
  26.                     MyTreadScopeData myTreadScopeData=new MyTreadScopeData();
  27.                     myTreadScopeData.setName("chenxiaobing");
  28.                     myTreadScopeData.setAge(28);
  29.                     myThreadLocal.set(myTreadScopeData);
  30.                     new A().get();
  31.                     new B().get();
  32.                 }
  33.             }).start();
  34.         }
  35.  
  36.     }
  37.     static class A{
  38.         int data=x.get();
  39.         private void get(){
  40.             System.out.println("class A:"+Thread.currentThread().getName()+data);
  41.         //    MyTreadScopeData myThread=myThreadLocal.get();
  42.         //    myThread.setAge(30);
  43.         //    myThread.setName("aaaaaaaaaaaaaaa");
  44.             System.out.println("class A  myThreadLocal:"+Thread.currentThread().getName()+myThreadLocal.get().getName());
  45.         }
  46.     }
  47.  
  48.     static class B{
  49.         int data=x.get();
  50.         private void get(){
  51.             System.out.println("class B:"+Thread.currentThread().getName()+data);
  52.         //    MyTreadScopeData myThread=myThreadLocal.get();
  53.         //    myThread.setAge(30);
  54.         //    myThread.setName("bbbbbbbbbbbbbbbb");
  55.             System.out.println("class B  myThreadLocal:"+Thread.currentThread().getName()+myThreadLocal.get().getName());
  56.  
  57.         }
  58.     }
  59. }
  60.  
  61. class MyTreadScopeData{
  62.     private String name;
  63.     private int age;
  64.     public String getName() {
  65.         return name;
  66.     }
  67.     public void setName(String name) {
  68.         this.name = name;
  69.     }
  70.     public int getAge() {
  71.         return age;
  72.     }
  73.     public void setAge(int age) {
  74.         this.age = age;
  75.     }
  76.  
  77. }

输出：

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

单例模式：

  1. package com.test.shareData;
  2.  
  3. import java.util.Random;
  4.  
  5. /***
  6.  * @description 通过ThreadLocal实现，同一个线程范围内，不同的对象中数据共享
  7.  * 注意：一个ThradLocal只能代表一个变量，即只能放一个数据；多个线程范围内都需要共享数据，则需要定义多个ThreadLocal
  8.  * 另外：多个变量共享，同一个线程范围内共享，可通过创建实体对象，将实体对象放到ThreadLocal中
  9.  *
  10.  */
  11. public class ThreadLocalTest1 {
  12.  
  13.     private static ThreadLocal<Integer> x=new ThreadLocal<Integer>();
  14.     public static void main(String[] args) {
  15.         for(int i=0;i<2;i++){
  16.             new Thread(new Runnable(){
  17.                 @Override
  18.                 public void run() {
  19.                     int data=new Random().nextInt();
  20.                     x.set(data);
  21.                     System.out.println(Thread.currentThread().getName()+" data"+data);
  22.                     MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
  23.                     myTreadScopeData.setName("chenxiaobing"+data);
  24.                     myTreadScopeData.setAge(data);
  25.                     new A().get();
  26.                     new B().get();
  27.                 }
  28.             }).start();
  29.         }
  30.  
  31.     }
  32.     static class A{
  33.         int data=x.get();
  34.         private void get(){
  35.             System.out.println("class A:"+Thread.currentThread().getName()+data);
  36.             MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
  37.             System.out.println("class A  myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
  38.         }
  39.     }
  40.  
  41.     static class B{
  42.         int data=x.get();
  43.         private void get(){
  44.             System.out.println("class B:"+Thread.currentThread().getName()+data);
  45.             MyTreadScopeData1 myTreadScopeData =MyTreadScopeData1.getInstance();
  46.             System.out.println("class B  myThreadLocal:"+Thread.currentThread().getName()+myTreadScopeData.getName());
  47.         }
  48.     }
  49. }
  50.  
  51. class MyTreadScopeData1{
  52.  
  53.     private MyTreadScopeData1(){}//私有的构成方法，使其他无法创建实例对象
  54.  
  55.     //1.懒汉、饱汉模式的单例，预先定义一个静态的实例对象
  56.     /*private static MyTreadScopeData1 instance=new MyTreadScopeData1();
  57.     public static MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
  58.         return instance;
  59.     }*/
  60.  
  61.     //2.饿汉模式的单例，只有在需要时才创建实例对象
  62.     /*private static MyTreadScopeData1 instance=null;
  63.     public static synchronized MyTreadScopeData1 getInstance(){//定义一个可供其他调用的静态方法
  64.         if(null==instance){
  65.             instance =new MyTreadScopeData1();
  66.         }
  67.         return instance;
  68.     }*/
  69.  
  70.     //3.这里ThreadLocal的使用，类似1/2中的单例模式,只是1/2单例模式，所有线程都会共享MyTreadScopeData1的实例对象
  71.     private static ThreadLocal<MyTreadScopeData1> myThreadLocal=new ThreadLocal<MyTreadScopeData1>();
  72.  
  73.     //不同的线程共享不同的实例对象，不需要使用synchronized
  74.     public static MyTreadScopeData1 getInstance(){
  75.         MyTreadScopeData1 instance=myThreadLocal.get();
  76.         if(null==instance){
  77.             instance =new MyTreadScopeData1();
  78.             myThreadLocal.set(instance);
  79.         }
  80.         return instance;
  81.     }
  82.  
  83.     private String name;
  84.     private int age;
  85.     public String getName() {
  86.         return name;
  87.     }
  88.     public void setName(String name) {
  89.         this.name = name;
  90.     }
  91.     public int getAge() {
  92.         return age;
  93.     }
  94.     public void setAge(int age) {
  95.         this.age = age;
  96.     }
  97.  
  98. }

输出：

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实现线程范围内变量共享的更多相关文章

  1. 多线程（四） 实现线程范围内模块之间共享数据及线程间数据独立（Map集合）

    多个线程访问共享对象和数据的方式 1.如果每个线程执行的代码相同,可以使用同一个Runnable对象,这个Runnable对象中有那个共享数据,例如,买票系统就可以这么做. 2.如果每个线程执行的代码 ...

  2. 多线程（三） 实现线程范围内模块之间共享数据及线程间数据独立（ThreadLocal）

    ThreadLocal为解决多线程程序的并发问题提供了一种新的思路.JDK 1.2的版本中就提供java.lang.ThreadLocal,使用这个工具类可以很简洁地编写出优美的多线程程序,Threa ...

  3. ThreadLocal实现线程范围内共享

    线程范围内共享,即是对相同一段代码,在不同的模块调用时使用一份数据,而在另外一个线程中又使用另外一份数据. ThreadLocal使用set方法为一个新的线程增加一条记录,key是各自的线程,valu ...

  4. 线程：ThreadLocal实现线程范围内共享变量

    在web应用中,一个请求(带有请求参数)就是一个线程,那么如何区分哪些参数属于哪个线程呢?比如struts中,A用户登录,B用户也登录,那么在Action中怎么区分哪个是A用户的数据,哪个是B用户的数 ...

  5. 线程系列4--Java线程范围内的共享数据（一）

    这张图片是我看传智播客的视频时的截屏,这个图片很直观的展示了线程范围内的数据共享.当同一个线程在执行三个不同业务模块时,这三个业务模块访问的数据是共享的.更直白的说,当一个执行线索在穿个每个业务模块时 ...

  6. java多线程与线程并发四：线程范围内的共享数据

    当多个线程操作同一个共有数据时,一个线程对共有数据的改变会影响到另一个线程.比如下面这个例子:两个线程调用同一个对象的的方法,一个线程的执行结果会影响另一个线程. package com.sky.th ...

  7. （Java多线程系列四）停止线程

    停止线程 停止线程的思路 ①使用退出标志,使线程正常退出,也就是当run()方法结束后线程终止. class Thread01 extends Thread { // volatile关键字解决线程的 ...

  8. 【Java多线程系列四】控制线程执行顺序

    假设有线程1/线程2/线程3,线程3必须在线程1/线程2执行完成之后开始执行,有两种方式可实现 Thread类的join方法:使宿主线程阻塞指定时间或者直到寄生线程执行完毕 CountDownLatc ...

  9. ThreadLocal实现线程范围的共享变量

    一.如何理解线程范围内共享数据 1.static int num=0; 2.线程1访问num变量,并设置为num=2:线程2访问num变量,并设置为num=3: 3.当线程1中对象A.B.C 在访问线 ...

随机推荐

  1. [Swift实际操作]九、完整实例-(2)在Xcode 10中创建新项目

    本文将在Xcode中创建上一文<在iTunesConnect网站中创建产品>在iTunes Connect创建的产品具有相同的Bundle ID的应用程序. 在项目模板窗口中,选择单视图模 ...

  2. pip_install的安装

    1.下载get-pip.py https://pip.pypa.io/en/latest/installing/#id9 2.运行 python get-pip.py 3.python -m pip ...

  3. 【智能算法】变邻域搜索算法(Variable Neighborhood Search,VNS)超详细解析和TSP代码实例以及01背包代码实例

    喜欢的话可以扫码关注我们的公众号哦,更多精彩尽在微信公众号[程序猿声] 00 目录 局部搜索再次科普 变邻域搜索 造轮子写代码 01 局部搜索科普三连 虽然之前做的很多篇启发式的算法都有跟大家提过局部 ...

  4. 关于使用self.title文字不居中的解决办法

    最放发现,使用Segue在对视图切换,左上角的一般都是<Back 的一个Button控键或者是上一个视图的<title .因为上一个视图的title名字太长,导致当前视图的title被挤压 ...

  5. (C/C++) 基本排序法

    C++ Class 宣告 class Sort{ private: void Merge(int *arr, int front, int mid, int end); int Partition(i ...

  6. 扩展jQuery---选中指定索引的文本

    <script type="text/javascript"> //1.扩展jQuery $.fn.selectRange = function (start, end ...

  7. Java getMethod类型参数

    public class DynamicInvoker { public static void main(String[] args) { // TODO Auto-generated method ...

  8. asp.net MVC中的@model与Model

    asp.net MVC中的@model与Model https://blog.csdn.net/ydm19891101/article/details/44301201 在MVC的实际使用中,我们经常 ...

  9. sharepoint_study_3

    SharePoint网页无法打开 描述:安装部署好SharePoint开发环境后,再修改计算机的机器名,重启计算机后,发现SharePoint网站不能打开. 解决:1.将机器名改回去,重启计算机,问题 ...

  10. 【记录】drozer与adb工具的安装与使用

    drozer:链接:https://pan.baidu.com/s/1o8QOIF4 密码:a7yv adb:链接:https://pan.baidu.com/s/1o865VSm 密码:zq9t d ...