精华内容
下载资源
问答
  • 共享变量

    2017-03-17 13:38:59
    java中对于共享变量的定义是这样的: 共享变量包括所有的实例变量,静态变量和数组元素。他们都被存放在堆内存中

    java中对于共享变量的定义是这样的:
    共享变量包括所有的实例变量,静态变量和数组元素。他们都被存放在堆内存中

    展开全文
  • labview共享变量

    2017-02-23 22:48:21
    labview共享变量的使用。
  • Spark 共享变量

    2019-06-27 14:41:54
    翻译 Spark 共享变量部分的官方文档(Spark 2.4.3)。 通常,当传递给 Spark 操作 (如 map 或 reduce ) 的函数在远程集群节点上执行时,在函数中使用的所有外部变量都是单独拷贝的变量副本。这些变量被复制到每台...

    翻译 Spark 共享变量部分的官方文档(Spark 2.4.3)。

    通常,当传递给 Spark 操作 (如 map 或 reduce ) 的函数在远程集群节点上执行时,在函数中使用的所有外部变量都是单独拷贝的变量副本。这些变量被复制到每台机器上,对远程机器上的变量更新不会传播回驱动程序。支持通用的、任务间的读写共享变量是很低效的。不过,Spark确实为两种常见的使用模式提供了两种有限的共享变量类型:广播变量累加器

    一、广播变量

    广播变量允许程序员在每台机器上保留一个只读变量,而不是给每个 task 都发送一份它的副本。 例如,它们可用于使用一个有效的方式为每个节点提供很大的输入数据集的副本。 Spark 还尝试使用有效的广播算法来分发广播变量,以降低通信成本。

    Spark 的所有 action 操作都是贯穿着很多个 stage 的,这些 stage 由 shuffle 操作进行划分。 Spark 自动广播每个 stage 中任务所需的公共数据。以这种方式广播的数据是以序列化形式缓存并在运行每个 task 之前进行反序列化。所以,广播变量在多个 stage 中的所有 task 都需要一份同样的数据这样的场景中很有用。

    广播变量是通过 SparkContext.broadcast(v) 这样的方式创建的。它是将原始变量 v 包裹到自己封装的变量中去,然后通过 .value() 这个方法获取原始变量的值,代码如下:

    Broadcast<int[]> broadcastVar = sc.broadcast(new int[] {1, 2, 3});
    
    broadcastVar.value();
    // returns [1, 2, 3]
    

    当广播变量被创建之后,在集群上所有的计算函数中都会使用广播变量去计算,因此原始变量 v 就不需要多次被复制到很多个节点上了。另外,原始变量 v 在广播变量被创建之后不可再被修改,如果在广播变量创建之后再去修改原始变量 v 会导致集群中每个节点拿到的共享变量值不一样。

    二、累加器

    累加器内部是通过关联和交换操作实现 “add” 操作的变量,因此可以并发执行。它可以用来实现计算器或者求和操作。Spark 天然支持数值类型的累加,程序员也可以自定义一些新的数据类型用来累加。

    作为用户,你可以创建命名或者未命名的累加器。如下图所示,一个命名的累加器(counter) 会被展示在使用该累加器的 stage 的 web UI 上面。 Spark 会展示每一个被 Tasks 表中的任一个 task 修改过的累加器的值。

    累加器

    在 UI 中追踪累加器的值可以帮助理解运行中的各个 stage 的进度。

    一个数字类型的累加器可以通过这样的方式创建:SparkContext.longAccumulator() 或者 SparkContext.doubleAccumulator() ,去计算 long 类型或者 double 类型的数值累加。集群中每个 task 在做累加计算任务的时候可以通过调用 add 方法去实现。但是,不可以在集群上读取累加器的值。只有在 driver 程序中才可以读取累加器的值,通过 value 这个方法。

    下面的这段代码是用累加器去将一个 array 中的每个元素相加:

    LongAccumulator accum = jsc.sc().longAccumulator();
    
    sc.parallelize(Arrays.asList(1, 2, 3, 4)).foreach(x -> accum.add(x));
    // ...
    // 10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s
    
    accum.value();
    // returns 10
    

    除了在代码中使用内建的 long 类型的累加器之外,程序员也可以通过继承 AccumulatorV2 去实现想要的类型的累加器。AccumulatorV2 这个抽象类有很多个方法需要去重写,如:reset 方法(用来将累加器置零的)、add 方法(用来和另外一个值做累加的)、merge 方法(用来合并另外一个相同类型的累加器到该累加器的)。其它需要被重写的方法可以参考 API documentation 。比如,我们可以自定义一个累加器 MyVector 代表数学中的向量集合,可以这么写:

    class VectorAccumulatorV2 implements AccumulatorV2<MyVector, MyVector> {
    
      private MyVector myVector = MyVector.createZeroVector();
    
      public void reset() {
        myVector.reset();
      }
    
      public void add(MyVector v) {
        myVector.add(v);
      }
      ...
    }
    
    // Then, create an Accumulator of this type:
    VectorAccumulatorV2 myVectorAcc = new VectorAccumulatorV2();
    // Then, register it into spark context:
    jsc.sc().register(myVectorAcc, "MyVectorAcc1");
    

    注意一点,当程序员自定义了一些数据类型的累加器之后,累加器的值的数据类型可以和你相加的元素类型不一致。

    注意 :当 Spark 的 task 计算任务结束后,Spark 将会尝试着将这个 task 中所有的累加计算合并到一个累加器上去。如果合并失败,Spark 会忽略这次失败,仍然认为这个 task 的计算任务是成功的,并且继续跑其它的 task。所以,一个有 bug 的累加器将不会影响 Spark 的作业,但一个累加器可能会在整个 Spark 作业成功跑完之后还没有成功更新到最新的值。

    由于累加器的 update 操作只会在 action 算子内部执行,Spark 保证了每个 task 对累加器的更新操作只有一次。比如重启 task 不会更新累加器的值。在 transform 算子操作时,用户需要知道每个 task 对累加器的更新操作可能不止一次,比如一但某个 task 或者 job 的 stage 被重新执行。

    累加器不会改变 Spark 的 lazy 特性。如果累加器的值在 RDD 某个操作中被更新了,他们的值只会在这个 RDD 的某个 action 操作的某个部分计算中更新。因此,累加器的更新不会保证在像 map 这样的算子中被立刻更新。可以看下面的代码片段:

    LongAccumulator accum = jsc.sc().longAccumulator();
    data.map(x -> { accum.add(x); return f(x); });
    // Here, accum is still 0 because no actions have caused the `map` to be computed.
    
    展开全文
  • 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());
    

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

    展开全文
  • 共享变量可见性

    千次阅读 2017-05-21 19:28:09
    可见性:多线程环境下,一个线程修改共享变量,能够及时被其他线程所感知 共享变量:一个变量在多个线程的工作内存都存在副本,这个变量就是共享变量 线程对共享变量的操作只能在自己的工作内存中进行,不能主...
    可见性:多线程环境下,一个线程修改共享变量,能够及时被其他线程所感知
    共享变量:一个变量在多个线程的工作内存都存在副本,这个变量就是共享变量


    线程对共享变量的操作只能在自己的工作内存中进行,不能主内存中操作
    不同线程之间无法访问其他线程工作内存中的变量,线程间变量值的传递通过主内存完成


    共享变量的可见性实现原理:线程1修改共享变量后,立刻更新主内存,然后线程2立刻从主内存把值更新到线程2的工作内存


    synchronized实现可见性:
    加锁时,清空工作内存中共享变量的值,从主内存读取最新的值。
    解锁前,将工作内存中共享变量的值更新到主内存中


    指令重排序:代码书写顺序与实际执行顺序不同,指令重排序是编译器或处理器为了提高执行效率做的优化
    编译器优化的指令重排序、指令并行的重排序、内存系统的重排序


    as-if-serial:无论如何重排序,程序执行的结果与代码顺序执行的结果一致


    volatile实现可见性原理:通过加入内存屏障和禁止重排序实现,对volatile变量读操作,会在操作前加一个load屏障指令;写操作后,加上一个store指令


    synchronized和volatile比较
    synchronized需要加锁,volatile不需要加锁,volatile不会阻塞线程执行效率高
    synchronized保证可见性和原子操作,volatile保证可见性和不保证原子操作
    展开全文
  • PB:关于共享变量与实例变量

    千次阅读 2018-04-08 17:24:19
    共享变量却是这个类所有实例共享的,在内存中永远只有一片内存,如果某个实例修改了这个共享变量,那其它实例读取时就是修改后的内容。 共享变量 一个属于对象定义的变量,并且存在于对象的所有实例中。当一个...
  • 文章目录multiprocessing中的共享变量进程间共享变量threading的共享变量 不同的进程默认有自己独立的内存空间,互相之间不能直接访问。所以,通常的全局变量或者传递参数,在创建新进程时,都是拷贝一份。比如下面...
  • Spark共享变量(广播变量、累加器)

    万次阅读 多人点赞 2018-04-01 19:02:46
    Spark两种共享变量:广播变量(broadcast variable)与累加器(accumulator)累加器用来对信息进行聚合,而广播变量用来高效分发较大的对象。共享变量出现的原因:通常在向 Spark 传递函数时,比如使用 map() 函数...
  • RDD与共享变量

    2018-06-15 17:45:55
    RDD和共享变量是Spark中的两个重要抽象。 RDD 弹性分布式数据集, 是分布式内存的一个抽象概念,RDD提供了一种高度受限的共享内存模型,即RDD是只读的记录分区的集合,只能通过在其他RDD执行确定的转换操作(如...
  • 什么是共享变量 通常情况下,当向Spark操作(如map,reduce)传递一个函数时,它会在一个远程集群节点上执行,它会使用函数中所有变量的副本。这些变量被复制到所有的机器上,远程机器上并没有被更新的变量向驱动程序...
  • java多线程之共享变量

    2018-12-25 15:35:01
    目的:简述java多线程的共享变量 共享变量:多个线程都会使用到的同一变量。 Q : 为什么共享变量会造成数据的错误呢??? A : 多个线程在操作共享变量的时候,不是直接在主内存中去操作的。而是都取一个...
  • python类共享变量详解

    千次阅读 2018-08-27 11:40:43
    python类共享变量,是不需要实例化就可以调用的, 比如类A有一个XXX的类共享变量, 直接A.xxx就可以调用 第一步:b在实例化的时候类A中没有共享变量xxx,这个时候实例b是没有这个变量 第二步...
  • 共享变量的使用

    2017-10-12 12:51:57
    但是,有时候,需要在多个任务之间共享变量,或者在任务(Task)和任务控制节点(Driver Program)之间共享变量。为了满足这种需求,Spark提供了两种类型的变量:广播变量(broadcast variables)和累加器...
  • Labview共享变量实现网络通信,也可以在局域网实现通信。
  • Java多线程共享变量控制

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

    千次阅读 2018-07-17 12:16:52
    python多进程共享变量 以下代码创建10个进程,并发访问一个存储了变量的字典。 #!/usr/bin/python #-*- coding: UTF-8 -*- # # @file: test.py # # 测试 # # @author: master@pepstack # # @create: $create$ # # ...
  • 通常,如下操作rdd.transformation(func),func所需要的外部变量都会以副本的形式从Driver端被发送到每...为此,Spark提供了两种类型的共享变量:广播变量、累加器。 广播变量 广播变量,Execoutor中的只读变量。在Dr...
  • 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...
  • extern 关键字声明多文件共享变量我们在C++开发中经常会遇到一些场景需要多个cpp文件同时共享一个变量,这个时候有两种选择,1、使用static 关键字;2、使用extern 关键字,而本文着重讲的便是extern 关键字 如何...
  • 2.什么情况下使用共享变量?3.如何在程序中使用共享变量?4.广播变量源码包含哪些内容?spark编程中,我们经常会遇到使用全局变量,来累加或则使用全局变量。然而对于分布式编程这个却与传统编程有着很大的区别。不...
  • 设置共享变量 获取共享变量
  • spark中的共享变量

    2017-09-08 09:46:35
    Spark一个非常重要的特性就是共享变量。默认情况下,如果在一个算子的函数中使用到了某个外部的变量,那么这个变量的值会被拷贝到每个task中。此时每个task只能操作自己的那份变量副本。如果多个task想要共享某个...
  • 以前没有接触过 共享变量, 和全局变量;在网上找了相关资料如下;得出的结论是:因为每个可执行程序都会有自己的内存控件,所以全局变量只能在可执行程序内部的不同VI之间共享数据。全局变量不能在两个可执行程序...
  • 一、共享变量 二、广播变量 三、累加器
  • Spark核心编程-共享变量

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,032
精华内容 17,212
关键字:

共享变量