精华内容
下载资源
问答
  • 共享变量是指
    千次阅读
    2022-03-02 09:51:07

    python中多进程共享内存主要有multiprocessing.Manager()、 multiprocessing的shared_memory的方法,这两种方法都是python内置模块,其中shared_memory是python3.8之后新加入的功能,如果使用必须要用python3.8以上的版本。以下介绍两种方式的区别:

    1.multiprocessing.Manager()

    有多个数据类型可以使用,包括Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array,等数据类型。

    示例代码段:

    # -*- coding:utf-8 -*-
    from multiprocessing import Process, Manager
    import time
    import random
    def kkk(a_list, number):
      for i in range(10):
        a_list.append(i)
        time.sleep(random.randrange(2))
        print('这是进程{} {}'.format(number, a_list))
      print('这是进程{} {}'.format(number, a_list))
    def jjj(a_list):
      for i in range(2):
        process = Process(target=kkk, args=(a_list, i))
        process.start()
    if __name__ == '__main__':
      manager = Manager()
      a_list = manager.list()
      # a_list = []
      process_0 = Process(target=jjj, args=(a_list,))
      process_0.start()
      process_0.join()
      print(a_list)
      print(len(a_list))
      print('it\'s ok')

    2.shared_memory和shareableList

     SharedMemory 用于多核或对称多处理器(SMP)计算机上的一个或多个进程访问的共享内存的分配和管理。为了帮助共享内存的生命周期管理,特别是在不同的进程中,一个 BaseManager 子类, SharedMemoryManager ,也在 multiprocessing.managers 模块。

    在这个模块中,共享内存指的是“SystemV样式”的共享内存块(尽管不一定要这样明确地实现),而不是“分布式共享内存”。这种类型的共享内存允许不同的进程潜在地读写到易失性内存的公共(或共享)区域。通常情况下,进程只能访问自己的进程内存空间,但共享内存允许进程之间共享数据,从而避免了在包含该数据的进程之间发送消息的需要。与通过磁盘或套接字或其他需要数据序列化/反序列化和复制的通信共享数据相比,直接通过内存共享数据可以提供显著的性能优势。

    示例代码:

    from multiprocessing import shared_memory
    shm_a = shared_memory.SharedMemory(create=True, size=10)
    type(shm_a.buf)
    <class 'memoryview'>
    buffer = shm_a.buf
    len(buffer)
    10
    buffer[:4] = bytearray([22, 33, 44, 55])  # Modify multiple at once
    buffer[4] = 100                           # Modify single byte at a time
    # Attach to an existing shared memory block
    shm_b = shared_memory.SharedMemory(shm_a.name)
    import array
    array.array('b', shm_b.buf[:5])  # Copy the data into a new array.array
    array('b', [22, 33, 44, 55, 100])
    shm_b.buf[:5] = b'howdy'  # Modify via shm_b using bytes
    bytes(shm_a.buf[:5])      # Access via shm_a
    b'howdy'
    shm_b.close()   # Close each SharedMemory instance
    shm_a.close()
    shm_a.unlink()  # Call unlink only once to release the shared memory

    3.总结对比

    我通过实验对比,总结了以下经验:

    1 sharedMemory和shareableList本质上是同一种实现机制,都会随共享内存空间增大,访问时间明显增大;multiprocessing.Manager()随共享内存空间增大,访问时间几乎不变。

    2 shareableList只支持小缓存(10M以内),且相同缓存大小情况下,shareableList效果比Manager好10倍

    3 需共享内存空间较小部分,推荐用shareableList;需共享内存空间较大部分,推荐用Manager

    如果你有了解的更好的python多进程共享机制,可以在下方评论告诉我。

    更多相关内容
  • Labview 共享变量

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

                                Labview 共享变量

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

     

    展开全文
  • 浅谈Java共享变量

    千次阅读 2021-02-12 13:42:06
    共享变量比较典型的就是类的成员变量,在类中定义了很多方法对成员变量的使用,如果是单实例,当有多个线程同时来调用这些方法,方法又没加控制,那么这些方法对成员变量的操作就会使得该成员变量的值变得不准确了...

    Java并发一直都是开发中比较难也比较有挑战性的技术,对于很多新手来说是很容易掉进这个并发陷阱的,其中尤以共享变量最具代表性,其实关于讲这个知识点网上也不少,但大象想讲讲自己对这个概念的理解。共享变量比较典型的就是指类的成员变量,在类中定义了很多方法对成员变量的使用,如果是单实例,当有多个线程同时来调用这些方法,方法又没加控制,那么这些方法对成员变量的操作就会使得该成员变量的值变得不准确了。

    大象用一个最典型的i++例子来说明:

    publicclassTest {

    private int i= 0;

    private finalCountDownLatchmainLatch=newCountDownLatch(1);

    public voidadd(){i++;

    }

    privateclassWorkextendsThread{

    privateCountDownLatchthreadLatch;publicWork(CountDownLatch latch){

    threadLatch=

    latch;

    }

    @Override

    publicvoidrun() {

    try{

    mainLatch.await();

    }catch(InterruptedException e) {

    e.printStackTrace();}

    for(intj

    = 0; j < 1000; j++) {

    add();

    }

    threadLatch.countDown();

    }

    }

    publicstaticvoidmain(String[] args)throwsInterruptedException {

    for(intk

    = 0; k < 10; k++){

    Test test =newTest();

    CountDownLatch threadLatch =newCountDownLatch(10);

    for(inti

    = 0; i < 10; i++) {

    test.newWork(threadLatch).start();

    }

    test.mainLatch.countDown();

    threadLatch.await();

    System.out.println(test.i);

    }

    }}

    java.util.concurrent.CountDownLatch是JDK5.0提供的关于并发的一个新API,它的作用就像一个门闩或是闸门那样。上面这段代码一共执行10次,每次启动10个线程同时执行。mainLatch.await()相当于门闩挡着线程,让准备好的线程处于等待状态,当所有的线程都准备好时再调用mainLatch.countDown()方法,打开门闩让线程同时执行。我在这里用这个类的原因,是想让我创建的10个线程都准备好后再一起并发执行,这样才能很明显的看出add方法里面的i++效果。如果不引入CountDownLatch,只执行test.newWork(threadLatch).start(),则获得的结果可能看不出来线程竞争共享变量产生的错误情况。threadLatch这个CountDownLatch的作用是让10个线程都执行完run方法的for循环后通知主线程的threadLatch.await()停止等待打印出当前i的值。这段代码我加了-server参数运行了多次,每次结果都不一样,我取了几个比较明显的结果。当然,你也可以多运行几次看看效果。

    6663f64f15022c8b8511f827043a1ee4.png

    8a7d447fbe2b49a744c4dd22a1cc823d.png

    d7c1480a455dbe9fea4cc52903d63074.png

    共享变量i没做任何同步操作,当有多个线程都要读取并修改它时,问题就产生了。正确的结果应该是10000,但是我们看到了,不是每次结果都是10000。我这段代码最初的版本不是这样的,因为现在的CPU哪怕是家用级PC的CPU核心频率都非常高,所以完全看不出效果,在和一个朋友的讨论中,他给出了修改的建议,最后改为上面的代码,在这里谢谢Sunny君。run方法中的循环次数越大,i的并发问题就越明显,大家可以动手试下。对于上图的运行结果,和硬件平台有关,也和-server参数有关。有同学会有疑问了,既然共享变量没加同步处理,那为什么还是会出现10000的结果呢?关于这点我想这可能是JVM优化的结果,对于JVM(HotSpot)大象还没有很深入的研究,不敢随便下结论,请知道的朋友帮忙解答一下。

    在Java中,线程是怎么操作共享变量的呢?我们都知道,Java代码在编译后会变成字节码,然后在JVM里面运行,而像实例域(i)这样的变量是存储在堆内存(Heap

    Memory)中的,堆内存是内存中的一块区域。线程的执行其实说到底就是CPU的执行,当今的CPU(Intel)基本上都是多核的,因此多线程都是由多核CPU来处理,并且都有L1、L2或L3等CPU缓存,CPU为了提高处理速度,在执行的时候,会从内存中把数据读到缓存后再操作,而每个线程执行add方法操作i++的过程是这样的:

    1、线程从堆内存中读取i的值,将它复制到缓存中

    2、在缓存中执行i++操作,并将结果赋给变量i

    3、再用缓存中的值刷新堆内存中的变量i的值

    我上面写的这三步并不是严格按照JVM及CPU指令的步骤来的,但过程就是这么一回事,方便大家理解。通过上面这个过程我们可以看出问题了,如果有多个线程同时要修改i,那么都需要先读取堆内存中的变量i值,然后把它复制到缓存后执行i++操作,再将结果写回到堆内存的变量i中。这个执行的时间非常短,可能只有零点几纳秒(主要还是跟硬件平台有关),但还是出现了错误。产生这种错误的原因是共享变量的可见性,线程1在读取变量i的值的时候,线程2正在更新变量i的值,而线程1这时看不到线程2修改的值。这种现象就是常说的共享变量可见性。

    下图是线程执行的抽象图,也可以说是Java内存模型的抽象示意图,可能不严谨,但大意是这样的。

    cafefcafb80ecf741aa0b528c682ccb4.png

    现在选用开发框架一般都会选择Spring,或是类似Spring这样的东西,而代码中经常用到的依赖注入的Bean如果没做处理一般都会是单例模式。试想一下,按下面这个方式引用Service或其它类似的Bean,在UserService中又不小心用到了共享变量,同时没有处理它的共享可见性,即同步,那将会产生意想不到的结果。不光Service是单例的,Spring MVC中的Controller也是单例的,所以编写代码的时候一定要注意共享变量的问题。

    @Autowired

    privateUserServiceuserService;

    所以我们要尽可能的不使用共享变量,避开它,因为处理好共享变量可见性不是一个很简单的问题。如果有非用不可的理由,请使用java.util.concurrent.atomic包下面的原子类来代替常用变量类型。比如用AtomicInteger代替int,AtomicLong代替long等等,具体可以参考API文档。如果需求比这更复杂,那还得想其它解决办法。

    以上是大象关于共享变量的一些浅薄见解,有什么不对的,还请各位指出来。本文为菠萝大象原创,如要转载请注明出处。

    posted on 2014-06-10 16:09 菠萝大象 阅读(8080) 评论(5)  编辑  收藏 所属分类: Concurrency

    展开全文
  • 变量共享是进行线程间通信的常用手段之一,java的内存模型(JMM)解决了可见性和有序性,我们则可以通过线程锁保证原子性。 共享继承Runnable将变量作为成员变量变量定义为final直接访问 有变量: class ShareData...

    变量共享是进行线程间通信的常用手段之一,java的内存模型(JMM)解决了可见性和有序性,我们则可以通过线程锁保证原子性。


    有变量:

    class ShareData {
        int num = 0;
        
        public synchronized void inrc() {
            num++;
        }
        
        public synchronized void desc() {
            num--;
        }
    }
    

    常用的变量共享手段有:

    继承Runnable将变量作为成员变量

    public static void main(String[] args) {
            ShareData shareData = new ShareData();
            InrcRunnable incrRun = new InrcRunnable(shareData);
            DescRunnable descRun = new DescRunnable(shareData);
            new Thread(incrRun).start();
            new Thread(descRun).start();
    }
    class InrcRunnable implements Runnable {
        ShareData shareData;
        
        public InrcRunnable(ShareData shareData) {
            this.shareData = shareData;
        }
        
        @Override
        public void run() {
            shareData.inrc();
        }
    }
    class DescRunnable implements Runnable {
        ShareData shareData;
        
        public DescRunnable(ShareData shareData) {
            this.shareData = shareData;
        }
        
        @Override
        public void run() {
            shareData.desc();
        }
    }
    

    将变量定义为final直接访问

    public static void main(String[] args) {
        final ShareData shareData = new ShareData();
        new Thread(new Runnable() {
            @Override
            public void run() {
                shareData.inrc();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                shareData.desc();
            }
        }).start();
    }
    

    jdk1.8不再需要添加final修饰符,这是因为该版本的jdk会隐式的为这些变量添加final修饰词。

    PS:
    【JAVA核心知识】系列导航 [持续更新中…]
    上篇导航:16:volatile关键字:变量可见性与禁止重排序
    下篇导航:17.2:线程间通信Exchanger
    欢迎关注…

    展开全文
  • 先看下面问题:多个线程访问全局变量x,然后将x与i累加,启动10个线程,想让每个线程的输出结果都是一样的55,但是实际不是的。 package ThreadTest; public class Counter { private int x...
  • 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...
  • 那么问题来了,共享变量,不应该存在堆区的变量吗,比如对象中的成员变量,那么在线程中(即栈中对共享变量)的修改是通过地址找到堆中的变量直接在堆中进行的修改,而且栈中只拥有堆中变量的索引地址,那么这个...
  • 多线程——线程范围内变量共享

    千次阅读 2020-09-28 21:32:24
    线程范围内的共享变量对同一个变量,几个线程同时对它进行写和读操作,而同一个线程读到的数据就是它自己写进去的数据。 1、未实现变量共享的例子: import java.util.Random; public class NotShareVarThread ...
  • 关于共享变量、临界区、临界资源、进程互斥之间的一些定义与理解;
  • 多进程共享变量故障的静态检测方法,宋颖,宫云战,多进程共享变量故障是多个进程没有按照一定的规则访问同一个变量,在运行时会导致系统结果错误甚至程序崩溃的一类故障。目前专
  • Java多线程共享变量控制

    千次阅读 2019-06-27 21:44:54
    如果一个线程对共享变量值的修改,能够及时的被其他线程看到,叫做共享变量的可见性。如果一个变量同时在多个线程的工作内存中存在副本,那么这个变量就叫共享变量 2. JMM(java内存模型) 多个线程同时对主内存的...
  • tensorflow里面共享变量、name_scope, variable_scope等如何理解 name_scope, variable_scope目的:1 减少训练参数的个数。 2 区别同名变量 为什么要共享变量?我举个简单的例子:例如,当我们研究生成对抗网络GAN的...
  • Java多线程变量共享与隔离

    千次阅读 2021-11-12 11:38:42
    而主内存也就是的是内存,也就是原始的共享变量存放的位置。 一个线程A对共享变量1的修改对线程B可见,需要经过下列步骤: 线程A将更改变量1后的值更新到主内存 主内存将更新后的变量1的值更新到线程B的工作内存中...
  • Java 中什么是引用变量

    千次阅读 2021-03-14 21:28:25
    **Java中什么是引用变量?**Java的引用变量实际上是一个指针,它指向的是堆内存中对象实例,就相当于是为数组或对象起的一个名称,然后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。**什么是堆, 什么...
  • Java并发:线程共享变量可见性原理

    千次阅读 2018-04-02 16:53:26
    0.1、线程之间的通信:线程的通信是线程之间以何种机制来交换信息。在命令式编程中,线程之间的通信机制有两种共享内存和消息传递。(1)在共享内存的并发模型里,线程之间共享程序的公共状态,线程之间通过写-读...
  • 共享变量在线程间的可见性

    千次阅读 2017-11-04 14:18:12
    共享变量在线程间的可见性  (1)有关可见性的一些概念介绍  可见性:一个线程对共享变量值的修改,能够及实地被其他线程看到。  共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几...
  • 这个问题的答案是静态变量和全局变量都可能引起线程安全问题。...产生线程安全问题的原因:静态变量即类变量,只初始化一次,位于方法区,为所有对象共享共享一份内存,一旦静态变量被修改,其他...
  •  线程范围内的共享变量对同一个变量,几个线程同时对它进行写和读操作,而同一个线程读到的数据就是它自己写进去的数据。也就是说每个线程只能访问他自己的,不能访问别的线程的。 首先我们看未实现范围内...
  • Java变量

    万次阅读 多人点赞 2019-09-29 00:06:53
    文章目录定义分类按被声明的位置划分成员变量局部变量成员变量和局部变量的区别使用原则按所属的数据类型划分基本数据类型变量引用数据类型变量定义格式注意事项 定义 在程序执行的过程中,在某个范围内其值可以...
  • 成员变量

    千次阅读 2021-12-03 14:53:26
    成员变量分为两种:类的成员变量和对象的成员变量(又称为实例变量) (1)成员变量的定义 声明成员变量语法如下: [public|protected|private][static][final]<type><variable_name> 各参数的含义...
  • 按键精灵全局环境变量

    千次阅读 2020-12-23 20:42:33
    全局变量就是在当前脚本内有效的变量,即全局变量在当前脚本里以及脚本里面的线程都有效,...在脚本内共享变量为了让线程能够访问到主脚本的变量,就必须把变量声明称全局变量。环境变量当然也可以,但是它作用的...
  • 成员变量与全局变量的区别

    千次阅读 2021-03-10 04:18:54
    全局变量:也叫成员变量,是在类中定义的变量;...实例变量:不用static修饰 它只能通过对象调用 而且所有对象的同一个实例变量共享不同的内存空间的局部变量:是那些在方法体中定义的变量以及方法...
  • 如何解决多线程-共享全局变量-问题

    千次阅读 2018-09-13 11:12:34
    解决多线程共享全局变量问题,在多线程中实现多任务难免会遇见共享全局变量问题,当多个线程同时对一个全局变量操作,会出现资源竞争问题,从而导致数据结不正确,即遇到线性安全问题 那么该如何解决呢? 引入同步...
  • 什么是线程安全和线程不安全

    千次阅读 2020-07-10 11:14:24
    当有多个线程共享同样的内存时: 如果 线程不会对内存进行读取和修改 内存是只读的 多个进程对这个内存进行修改,但是写是原子操作时 那么线程是安全的 当一个线程修改变量时,其他线程在读取这个变量时可能...
  • 网上罗列了很多关于变量的理解,良莠不齐,不知道哪些是对的,哪些是错的,所以笔者就这些博客和自己的理解写出这篇文章,如果有不对的地方,希望读者能够指正,感谢。 变量是我们经常用到的一种,我在刚学 Java 的...
  • 并发编程学习(8) —— 管程

    千次阅读 2019-04-16 09:52:54
    管程其实的是管理共享变量以及管理共享变量的操作过程。 在并发领域中,最主要解决两个问题,第一个问题就是互斥,即同一时间只对一个共享变量继续操作。第二个问题就是同步,线程间如何通信、协调。 管程解决互斥...
  • TensorFlow中的变量(Variables)

    万次阅读 2018-06-14 19:51:37
    在TensorFlow中,变量(Variable)是特殊的张量(Tensor),它的值可以是一个任何类型和形状的张量。与其他张量不同,变量存在于单个 session.run 调用的上下文之外,也就是说,变量存储的是持久张量,当训练模型时,用...
  • 一、类变量和实例变量的定义 |-成员变量:把类内、方法体外定义的变量称为成员变量。 |-类变量:有static修饰,称为类变量(静态变量); ... |-被所有对象所共享; |-可以直接被类名调用; ...
  • 主内存:其实就是JAVA堆内存,里面存放着程序中所有的类实例对象等变量,属于线程共享的。 工作内存:工作内存存放的是线程从主内存中拷贝过来的变量副本以及访问方法所得到的局部变量,是线程私有的。 总结 所以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 335,725
精华内容 134,290
热门标签
关键字:

共享变量是指

友情链接: apache-ant-1.10.1-bin.zip