精华内容
下载资源
问答
  • 变量类型:单进程;网络发布;时间触发的共享变量。后两种主要用于不同硬件设备、不同计算机、不同进程程序间的数据交换
  • 主要介绍了Java多线程编程之ThreadLocal线程范围内的共享变量,本文讲解了ThreadLocal的作用和目的、ThreadLocal的应用场景、ThreadLocal的使用实例等,需要的朋友可以参考下
  • 主要介绍了java通过共享变量结束run停止线程的方法,大家参考使用
  • 在LabVIEW平台下完成开发,利用labview的共享变量技术和opc技术,以服务器、客户端的形式完成计算机之间的网络通信、数据交换。
  • labview共享变量

    2017-02-23 22:48:21
    labview共享变量的使用。
  • LabVIEW RT的共享变量技术
  • 按照流程操作,即可以实现多台PC通讯,技术基于共享变量
  • 主要介绍了python使用锁访问共享变量实例解析,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • Labview共享变量实现网络通信,也可以在局域网实现通信。
  • python类共享变量操作

    2021-01-19 23:43:03
    python类共享变量,是不需要实例化就可以调用的, 比如类A有一个XXX的类共享变量, 直接A.xxx就可以调用 第一步:b在实例化的时候类A中没有共享变量xxx,这个时候实例b是没有这个变量 第二步:给类A 添加一个类共享...
  • Labview 共享变量

    千次阅读 2021-02-28 12:30:38
    Labview 共享变量 共享变量具有全局变量的所有特性,同事避免了数据竞争问题。使用范围远远超出了全局变量,可以在网络中的不同计算机之间相互通信。 如果需要在本地计算机创建和发布共享变量。需要安装Labview ...

                                Labview 共享变量

        共享变量具有全局变量的所有特性,同事避免了数据竞争问题。使用范围远远超出了全局变量,可以在网络中的不同计算机之间相互通信。
        如果需要在本地计算机创建和发布共享变量。需要安装Labview RT模块,其他计算机使用这个共享变量只需要通过DataSocket函数就可以直接使用。
        创建共享变量:
        1.创建项目。
        2.在项目中创建项目库。
        3.通过项目库快捷菜单,新建变量。
        创建变量时,会有对话框弹出。编辑名称,选择变量类型和数据类型等。

     

    展开全文
  • Java线程共享变量

    千次阅读 2019-12-04 15:16:46
    这篇文章描述两种线程共享实例变量的通用模型,一个Java线程是Thread类的实例,一个thread必须从一个thread base创建。一个thread包含一个thread base和隐藏的控制结构,隐藏的控制结构允许thread可以与其他线程并行...

    介绍

    这篇文章描述两种线程共享实例变量的通用模型,一个Java线程是Thread类的实例,一个thread必须从一个thread base创建。一个thread包含一个thread base和隐藏的控制结构,隐藏的控制结构允许thread可以与其他线程并行执行。
    每个Java应用至少包含两个线程,一个是主线程,另一个是垃圾回收线程。

    Thread Base

    thread base是以下一个class的实例

    • implements Runnable
    • extends Thread

    thread base必须拥有下面的方法
    public void run();

    第一个thread base必须定义run方法,是为了implements Runnable接口。第一个thread base是Thread类本身作为thread base,提供run方法的简单定义,继承这个类的class必须覆写这个简单定义。

    只要线程t从thread base中创建,通过执行start()方法来启动。

    方法1:共享thread base

    假如有一个implements Runnable的ThreadBase,主方法可以创建一个thread base:

    ThreadBase base = new ThreadBase();
    

    线程可以从同一个thread base中创建

    Thread A = new Thread(base, "A");
    Thread B = new Thread(base, "B");
    

    执行start()方法调用

    A.start();
    B.start();
    

    A和B共享thread base的成员变量,A和B拥有相同的run方法,但是他们的线程名字是不同的,仅仅成员变量可以共享,run方法使用的本地变量并不会共享。

    方法2:分开的bases

    假设除了main类还有三个类

    • Shared
    • ThreadA extends Thread
    • ThreadB extends Thread

    主方法创建一个对象,这个对象的成员变量要被线程共享。

    Shared s = new Shared();
    

    创建线程

    ThreadA A = new ThreadA(s);
    ThreadB B = new ThreadB(s);
    

    线程A和B使用不同的thread bases创建,A和B拥有不同的thread base。
    线程A和B通过构造函数传递对象s,线程A如下:

    class ThreadA extends Thread 
    {   
      ThreadA( Shared s ) { this.s = s; }  // set member = parameter
    
      private Shared s;
    
      ...
    }
    

    在线程A中的s成员变量指向原对象s。
    两种模型的区别

    • 模型1在thread base和thread之间做了明确区分,而模型2是thread base和thread进行了有效合并
    • 模型1中,线程共享成员变量,而在模型2中,仅仅指向的对象是共享的,模型2不能共享基础数据类型,如,int,boolean等等。必须只用包装类Integer,Float等等。
    • 当线程执行不同的操作时,模型2更容易使用,例如,协同问题,发布者/订阅者等等。

    Java互斥锁

    在Java中的每个对象都有一个内部lock(有一个locked变量)和一个阻塞线程的队列,互斥锁代码块可以通过synchronized关键字创建

    Object x = new Object();
    
    synchronized(x)
    {
    	// mutual exclusive access for all threads which share x
    }
    

    一个线程仅仅能够运行在synchronized(x)区域,如果它获得这个x锁。否则如果它尝试运行,将会阻塞。当一个线程离开这个区域,将会唤醒一个阻塞的线程。
    另一种方法创建互斥锁的方法是

    class MyClass {
      public synchronized void foo() {
         // ...
      }
    }
    

    在这种情况下,如果多个线程共享对象
    MyClass c = new MyClass();
    所有对c.foo()的调用都是互斥的。在MyClass类中对foo()方法的调用实际是this.foo(),在这种情况,this的lock被使用。

    两个线程共享计数

    假如两个线程共享integer counter,对counter的访问是在cs()方法中,我们想要确保在cs()方法的互斥。

    方法1

    class Main 
    {
      public static void main(String args[]) 
      {
        ThreadBase base = new ThreadBase();
    		
        Thread A = new Thread( base, "A" );
        Thread B = new Thread( base, "B" );
    		
        A.start(); B.start();
        // ...
      }
    }
    
    
    class ThreadBase implements Runnable 
    {
      int counter = 0;
      public void run() 
      {
        while (true) {
          /* non-critical section */
          cs();
        }
      }
    	
      private void cs() {
        int x = counter;  // read into non-shared variable
        x = x + 1;        // update (this could be more elaborate)
        counter = x;      // write
      }
    }
    

    线程A和B共享base对象。base对象是最适合添加lock的选择,有两种方法添加锁,后一种方法更好

    private void cs() {
      synchronized(this) { 
        /* body of cs() */
      }
    }
    
    private synchronized void cs() {
      /* body of cs() */
    }
    

    方法2

    class Main 
    {
      public static void main(String args[]) 
      {
        Counter c = new Counter();
    		
        Thread A = new ThreadA( c );
        Thread B = new ThreadB( c );
    		
        A.start(); B.start();
    		
        // ...
      }
    }
    
    class Counter 
    {
      int val = 0;      // for simplicity, val is not private
    }
    
    class ThreadA extends Thread 
    {
      private Counter c;
    	
      ThreadA( Counter c ) { this.c = c; }
    	
      public void run() 
      {
        while (true) {
          /* non-critical section */
          cs();
        }
      }
    	
      private void cs() {
        int x = c.val;  // read into non-shared variable
        x = x + 1;      // update (this could be more elaborate)
        c.val = x;      // write
      }
    }
    
    class ThreadB extends Thread 
    {
      private Counter c;
    	
      ThreadB( Counter c ) { this.c = c; }
      
      // everything else is identical to ThreadA
    }
    

    c对象是最适合添加锁的选择,仅仅有一种方式

    private void cs() 
    {
      synchronized(c) { 
        /* body of cs() */
      }
    }
    

    互斥锁方法可以作为Counter的成员方法

    class Counter 
    {
      private int val = 0;      // now we can make val private
      
      public synchronized void cs() {
        int x = val;
        x = x + 1;
        val = x;
      }
    }
    

    在这种情况下,cs()不是线程A和线程B的成员方法

    public void run() 
    {
      while (true) {
        /* non-critical section */
        
        c.cs();  // call cs() through Counter c
      }
    }
    
    展开全文
  • Spark共享变量

    千次阅读 2018-12-24 00:51:11
    Spark一个非常重要的特性就是共享变量。默认情况下,如果在一个算子的函数中使用到了某个外部的变量,那么这个变量的值会被拷贝到每个task中。此时每个task只能操作自己的那份变量副本。如果多个task想要共享某个...

            Spark一个非常重要的特性就是共享变量。默认情况下,如果在一个算子的函数中使用到了某个外部的变量,那么这个变量的值会被拷贝到每个task中。此时每个task只能操作自己的那份变量副本。如果多个task想要共享某个变量,那么这种方式是做不到的。
        Spark为此提供了两种共享变量
    Broadcast Variable(广播变量):Broadcast Variable会将使用到的变量,仅仅为每个节点拷贝一份,更大的用处是优化性能,减少网络传输以及内存消耗。
    Accumulator(累加变量):Accumulator则可以让多个task共同操作一份变量,主要可以进行累加操作。
            Spark提供的Broadcast Variable,是只读的。并且在每个节点上只会有一份副本,而不会为每个task都拷贝一份副本。因此其最大作用,就是减少变量到各个节点的网络传输消耗,以及在各个节点上的内存消耗。此外,spark自己内部也使用了高效的广播算法来减少网络消耗。可以通过调用SparkContext的broadcast()方法,来针对某个变量创建广播变量。然后在算子的函数内,使用到广播变量时,每个节点只会拷贝一份副本了。每个节点可以使用广播变量的value()方法获取值。记住,广播变量,是只读的。
            Spark提供的Accumulator,主要用于多个节点对一个变量进行共享性的操作。Accumulator只提供了累加的功能。但是确给我们提供了多个task对一个变量并行操作的功能。但是task只能对Accumulator进行累加操作,不能读取它的值。只有Driver程序可以读取Accumulator的值。

            默认情况下,算子的函数内,使用到的外部变量,会拷贝到执行这个函数的每一个task中。如果变量比较大,这个对网络传输成本很大,而且每个节点上也会占用比较大的内容
            如果把算子的函数使用到变量,做成一个共享变量,那么每个变量只拷贝一份到每个节点上,节点上的task都会共享这个变量

    在这里插入图片描述

    共享变量和累计变量伪代码

    int factnum=3;
            // 在java中,创建共享变量,就是调用SparkContext的broadcast()方法
            // 获取的返回结果是Broadcast<T>类型
            final Broadcast<Integer> fact=sc.broadcast(factnum);
            // 创建Accumulator变量
            // 需要调用SparkContext的accumulator()方法
            final Accumulator<Integer> sum=sc.accumulator(0);
            List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);
            JavaRDD<Integer> lists=sc.parallelize(list);
            lists.foreach(new VoidFunction<Integer>() {
                @Override
                public void call(Integer i) throws Exception {
                    // 使用共享变量时,调用其value()方法,即可获取其内部封装的值
                    System.out.println(i*fact.value());
                    // 然后在函数内部,就可以对Accumulator变量,调用add()方法,累加值
                    sum.add(i);
                }
            });
            // 在driver程序中,可以调用Accumulator的value()方法,获取其值
            System.out.println(sum.value());
    

    更多大数据技术请关注工作号

    展开全文
  • 线程安全性是我们在进行 Java 并发编程的时候必须要先考虑清楚的一个问题。...如何保证共享变量的原子性? 微信搜索「 沉默王二 」公众号,关注后回复「 免费视频 」获取 500G 高质量教学视频( 已分门别类 )。

    线程安全性是我们在进行 Java 并发编程的时候必须要先考虑清楚的一个问题。这个类在单线程环境下是没有问题的,那么我们就能确保它在多线程并发的情况下表现出正确的行为吗?

    我这个人,在没有副业之前,一心扑在工作上面,所以处理的蛮得心应手,心态也一直保持的不错;但有了副业之后,心态就变得像坐过山车一样。副业收入超过主业的时候,人特别亢奋,像打了鸡血一样;副业迟迟打不开局面的时候,人就变得惶惶不可终日。

    仿佛我就只能是个单线程,副业和主业并行开启多线程模式的时候,我就变得特别没有安全感,尽管整体的收入比没有副业之前有了很大的改善。

    怎么让我自己变得有安全感,我还没想清楚(你要是有好的方法,请一定要告诉我)。但怎么让一个类在多线程的环境下是安全的,有 3 条法则,让我来告诉你:

    1、不在线程之间共享状态变量。
    2、将状态变量改为不可变。
    3、访问状态变量时使用同步。

    那你可能要问,状态变量是什么?

    我们先来看一个没有状态变量的类吧,代码示例如下。

    class Chenmo {
        public void write() {
            System.out.println("我寻了半生的春天,你一笑便是了。");
        }
    }
    

    Chenmo 这个类就是无状态变量的,它只有一个方法,既没有成员变量,也没有类变量。任何访问它的线程都不会影响另外一个线程的结果,因为两个线程之间没有共享任何的状态变量。所以可以下这样一个结论:无状态变量的类一定是线程安全的

    然后我们再来看一个有状态变量的类。假设沉默(Chenmo 类)每写一行字(write() 方法),就要做一次统计,这样好找出版社索要稿费。我们为 Chenmo 类增加一个统计的字段,代码示例如下。

    class Chenmo {
        private long count = 0;
        public void write() {
            System.out.println("我寻了半生的春天,你一笑便是了。");
            count++;
        }
    }
    

    Chenmo 类在单线程环境下是可以准确统计出行数的,但多线程的环境下就不行了。因为递增运算 count++ 可以拆分为三个操作:读取 count,将 count 加 1,将计算结果赋值给 count。多线程的时候,这三个操作发生的时序可能是混乱的,最终统计出来的 count 值就会比预期的值小。

    PS:具体的原因可以回顾上一节《Java 并发编程(一):摩拳擦掌

    写作不易,咱不能亏待了沉默,对不对?那就想点办法吧。

    假定线程 A 正在修改 count 变量,这时候就要防止线程 B 或者线程 C 使用这个变量,从而保证线程 B 或者线程 C 在使用 count 的时候是线程 A 修改过后的状态。

    怎么防止呢?可以在 write() 方法上加一个 synchronized 关键字。代码示例如下。

    class Chenmo {
        private long count = 0;
        public synchronized void write() {
            System.out.println("我寻了半生的春天,你一笑便是了。");
            count++;
        }
    }
    

    关键字 synchronized 是一种最简单的同步机制,可以确保同一时刻只有一个线程可以执行 write(),也就保证了 count++ 在多线程环境下是安全的。

    在编写并发应用程序时,我们必须要保持一种正确的观念,那就是——首先要确保代码能够正确运行,然后再是如何提高代码的性能。

    但众所周知,synchronized 的代价是昂贵的,多个线程之间访问 write() 方法是互斥的,线程 B 访问的时候必须要等待线程 A 访问结束,这无法体现出多线程的核心价值。

    java.util.concurrent.atomic.AtomicInteger 是一个提供原子操作的 Integer 类,它提供的加减操作是线程安全的。于是我们可以这样修改 Chenmo 类,代码示例如下。

    class Chenmo {
        private AtomicInteger count = new AtomicInteger(0);
        public void write() {
            System.out.println("我寻了半生的春天,你一笑便是了。");
            count.incrementAndGet();
        }
    }
    

    write() 方法不再需要 synchronized 关键字保持同步,于是多线程之间就不再需要以互斥的方式来调用该方法,可以在一定程度上提升统计的效率。

    某一天,出版社统计稿费的形式变了,不仅要统计行数,还要统计字数,于是 Chenmo 类就需要再增加一个成员变量了。代码示例如下。

    class Chenmo {
        private AtomicInteger lineCount = new AtomicInteger(0);
        private AtomicInteger wordCount = new AtomicInteger(0);
        public void write() {
            String words = "我这一辈子,走过许多地方的路,行过许多地方的桥,看过许多次的云,喝过许多种类的酒,却只爱过一个正当年龄的人。";
            System.out.println(words);
            lineCount.incrementAndGet();
            wordCount.addAndGet(words.length());
        }
    }
    

    你觉得这段代码是线程安全的吗?

    结果显而易见,这段代码不是线程安全的。因为 lineCount 和 wordCount 是两个变量,尽管它们各自是线程安全的,但线程 A 进行 lineCount 加 1 的时候,并不能够保证线程 B 是在线程 A 执行完 wordCount 统计后开始 lineCount 加 1 的。

    该怎么办呢?方法也很简单,代码示例如下。

    class Chenmo {
        private int lineCount = 0;
        private int wordCount = 0;
        public void write() {
            String words = "我这一辈子,走过许多地方的路,行过许多地方的桥,看过许多次的云,喝过许多种类的酒,却只爱过一个正当年龄的人。";
            System.out.println(words);
            
            synchronized (this) {
                lineCount++;
                wordCount++;
            }
        }
    }
    

    对行数统计(lineCount++)和字数统计(wordCount++)的代码进行加锁,保证这两行代码是原子性的。也就是说,线程 B 在进行统计的时候,必须要等待线程 A 统计完之后再开始。

    synchronized (lock) {...}是 Java 提供的一种简单的内置锁机制,用于保证代码块的原子性。线程在进入加锁的代码块之前自动获取锁,并且退出代码块的时候释放锁,可以保证一组语句作为一个不可分割的单元被执行。


    上一篇:Java 并发编程(一):简介

    下一篇:如何保证共享变量的原子性?

    微信搜索「沉默王二」公众号,关注后回复「免费视频」获取 500G 高质量教学视频(已分门别类)。

    展开全文
  • Java多线程共享变量控制

    千次阅读 2019-06-27 21:44:54
    如果一个线程对共享变量值的修改,能够及时的被其他线程看到,叫做共享变量的可见性。如果一个变量同时在多个线程的工作内存中存在副本,那么这个变量就叫共享变量 2. JMM(java内存模型) 多个线程同时对主内存的...
  • python 多进程之间共享变量

    千次阅读 2019-04-03 10:35:09
    多线程 进程间共享变量等 1、进程间共享变量 self.val=Value('i',init_value) #进程间共享变量及列表类型 class Counter(object): def __init__(self, ini=0): self.val = Value('i', ini) self.lock = Lock...
  • Java中可以通过synchronized、volatile、java concurrent类来实现共享变量的可见性。 synchronized实现可见性 synchronized 实际上是对访问修改共享变量的代码块进行加互斥锁,多个线程对synchronized代码块的访问...
  • 模拟ThreadLocal类实现:线程范围内的共享变量,每个线程只能访问他自己的,不能访问别的线程。 package com.ljq.test.thread; import java.util.HashMap; import java.util.Map; import java.util.Random; /** ...
  • python3 多进程共享变量实现方法

    千次阅读 2019-12-10 11:44:40
    今天同事反映一个问题让帮忙看一下:多进程共用一个变量,在一个进程中修改后,在另外的进程中并没有产生修改。 一、错误的实现方式 最初以为是没添加global声明导致修改未生效,但实际操作发现global方式在多...
  • 一、题目: 创建线程,利用互斥实现线程共享变量通信 二、目的 掌握线程创建和终止,加深对线程和进程概念的理解,会用同步与互斥方法实现线程之间的通信。 三、内容和要求 软件界面上点“创建线程” 按钮,创建三个...
  • junit多个测试方法共享变量

    千次阅读 2018-12-14 15:41:47
    本文介绍利用类的静态属性实现junit多个测试方法间共享同一变量值。 package com.laoxu.gamedog; import org.junit.Test; /** * @author xusucheng * @create 2018-12-14 **/ public class ...
  • using OMP(二) 共享变量和私有变量

    千次阅读 2017-10-30 22:52:13
    Using OpenMP (一)共享变量和私有变量 2017/10/22    by CHENJING DING   CHAPTER1 – 基础知识 How to use OpenMPin Visual Studio 1. Start“new project” 2. Selectwin 32 console project 3. ...
  • JAVA多线程——共享变量

    千次阅读 2018-11-12 10:53:09
    【转载】Java多线程编程:变量共享分析(Thread) 原博客网址:https://www.cnblogs.com/xudong-bupt/archive/2013/05/22/3087864.html 今天看到java的多线程,感到十分激动,之前就在python中使用过多...
  • 一:远程共享变量设置 需要在局域网进行共享变量分享,可以子啊option中的sharedvariable engine中设置可以被搜索的电脑ip。并且可以设置连接过程持续的市场,也就是说超过这个时间还没连上就是超时了。 共享变量在...
  • 参考资料:PYTHON多模块文件共享变量 这个思路没问题,但在一个文件中修改后,在另一个文件中访问时还是原来的内容。 # 定义文件a.py x = 0 b.py import a a.x = 10 # 运行该文件 c.py import a print(a....
  • 易语言共享变量指针模块源码,共享变量指针模块,测试_共享类,测试_共享自定义数据类型,测试_共享数组,测试_共享基本数据类型,设置属性值,获取属性值,测试_数组,测试_文本,测试_类,共享变量指针,共享数据指针,还原指针...
  • java多线程之共享变量

    千次阅读 2018-12-25 15:35:01
    目的:简述java多线程的共享变量 共享变量:多个线程都会使用到的同一变量。 Q : 为什么共享变量会造成数据的错误呢??? A : 多个线程在操作共享变量的时候,不是直接在主内存中去操作的。而是都取一个...
  • ThreadLocal类就相当于一个Map,用于实现线程内的数据共享,即对于相同的程序代码,多个模块在同一个线程中运行时要共享一份数据,而在另外线程中运行时又共享另外一份数据。 每个线程调用全局ThreadLocal对象的set...
  • 上一篇,我们谈了谈如何通过同步来保证共享变量的原子性(一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行),本篇我们来谈一谈如何保证共享变量的可见性(多个线程访问同一个...
  • golang 基于共享变量的并发

    千次阅读 2018-05-11 16:09:58
    并发定义:当我们没有办法自信地确认一个事件是在另一个事件的前面或者后面发生的话,...只要有两个goroutine并发访问同一变量,且至少其中的一个是写操作的时候就会发生数据竞争。数据竞争会在两个以上的goroutine...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 780,546
精华内容 312,218
关键字:

共享变量