精华内容
下载资源
问答
  • 40. Python 多线程共享变量 线程池
    2020-12-10 11:14:24

    1.线程共享变量

    多线程和多进程不同之处在于,多线程本身就是可以和父线程共享内存的,这也是为什么其中一个线程挂掉以后,为什么其他线程也会死掉的道理。import threading

    def worker(l):

    l.append("li")

    l.append("and")

    l.append("lou")

    if __name__ == "__main__":

    l = []

    l += range(1, 10)

    print (l)

    t = threading.Thread(target=worker, args=(l,))

    t.start()

    print (l)

    返回结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]

    [1, 2, 3, 4, 5, 6, 7, 8, 9, 'li', 'and', 'lou']

    2.线程池(扩展内容,了解即可)

    通过传入一个参数组来实现多线程,并且它的多线程是有序的,顺序与参数组中的参数顺序保持一致。

    安装包:

    pip install  threadpool

    调用格式:from threadpool import *

    pool = TreadPool(poolsize)

    requests = makeRequests(some_callable, list_of_args, callback)

    [pool.putRequest(req) for req in requests]

    pool.wait()

    举例:import threadpool

    def hello(m, n, o):

    print ("m = {0}, n = {1}, o = {2}".format(m, n, o))

    if __name__ == "__main__":

    #方法一:

    lst_vars_1 = ['1','2','3']

    lst_vars_2 = ['4','5','6']

    func_var = [(lst_vars_1,None), (lst_vars_2, None)]

    #方法二:

    dict_vars_1 = {'m':'1','n':'2','o':'3'}

    dict_vars_2 = {'m':'4','n':'5','o':'6'}

    func_var = [(None, dict_vars_1), (None, dict_vars_2)]

    pool = threadpool.ThreadPool(2)

    requests = threadpool.makeRequests(hello, func_var)

    [pool.putRequest(req) for req in requests]

    pool.wait()

    返回结果:m = 1, n = 2, o = 3

    m = 4, n = 5, o = 6

    更多相关内容
  • Python写的多线程共享全局变量代码,用于学习多线程开发,可以直接运行,并且带中文注释,方便初学者学习使用。
  • 下面小编给大家分享一下Python多线程共享变量实现代码示例,小编觉得挺不错的,分享给大家供大家参考,有需要的小伙伴们可以来看看。多线程-共享全局变量#coding=utf-8from threading import Threadimport timeg_num...

    Python如何多线程共享变量?下面小编给大家分享一下Python多线程共享变量实现代码示例,小编觉得挺不错的,分享给大家供大家参考,有需要的小伙伴们可以来看看。

    多线程-共享全局变量

    #coding=utf-8

    from threading import Thread

    import time

    g_num = 100

    def work1():

    global g_num

    for i in range(3):

    g_num += 1

    print("----in work1, g_num is %d---"%g_num)

    def work2():

    global g_num

    print("----in work2, g_num is %d---"%g_num)

    print("---线程创建之前g_num is %d---"%g_num)

    t1 = Thread(target=work1)

    t1.start()

    #延时一会,保证t1线程中的事情做完

    time.sleep(1)

    t2 = Thread(target=work2)

    t2.start()

    执行如下:

    [root@server01 many_task]# python test5.py

    ---线程创建之前g_num is 100---

    ----in work1, g_num is 103---

    ----in work2, g_num is 103---

    [root@server01 many_task]#

    从上面两个线程执行的结果来看,线程t1将 g_num 加到 103,在线程t2也是打印g_num=103。所以对于两个线程,g_num这个全局变量是共享的。

    列表当做实参传递到线程中

    #coding=utf-8

    from threading import Thread

    import time

    def work1(nums):

    nums.append(44)

    print("----in work1---",nums)

    def work2(nums):

    #延时一会,保证t1线程中的事情做完

    time.sleep(1)

    print("----in work2---",nums)

    g_nums = [11,22,33]

    t1 = Thread(target=work1, args=(g_nums,))

    t1.start()

    t2 = Thread(target=work2, args=(g_nums,))

    t2.start()

    运行如下:

    [root@server01 many_task]# python test6.py

    ('----in work1---', [11, 22, 33, 44])

    ('----in work2---', [11, 22, 33, 44])

    总结:

    在一个进程内的所有线程共享全局变量,很方便在多个线程间共享数据

    缺点就是,线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱(即线程非安全)

    多线程-共享全局变量问题

    多线程开发可能遇到的问题

    假设两个线程t1和t2都要对全局变量g_num(默认是0)进行加1运算,t1和t2都各对g_num加10次,g_num的最终的结果应该为20。

    但是由于是多线程同时操作,有可能出现下面情况:

    在g_num=0时,t1取得g_num=0。此时系统把t1调度为”sleeping”状态,把t2转换为”running”状态,t2也获得g_num=0

    然后t2对得到的值进行加1并赋给g_num,使得g_num=1

    然后系统又把t2调度为”sleeping”,把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。

    这样导致虽然t1和t2都对g_num加1,但结果仍然是g_num=1

    编写代码测试如下:

    [root@server01 many_task]# vim test4.py

    #coding=utf-8

    import threading

    from time import sleep,ctime

    # 初始化g_num

    g_num = 0

    def add_func1(num):

    global g_num

    for i in range(num):

    g_num += 1

    print("add_func1,第%d次,g_num等于%d" % (i,g_num))

    #sleep(0.5)

    def add_func2(num):

    global g_num

    for i in range(num):

    g_num += 1

    print("add_func2,第%d次,g_num等于%d" % (i,g_num))

    #sleep(0.5)

    def main():

    # 执行线程

    t1 = threading.Thread(target=add_func1,args=(100,))

    t2 = threading.Thread(target=add_func2,args=(100,))

    t1.start()

    t2.start()

    # 判断当线程存在,则等待1秒

    while len(threading.enumerate()) > 1:

    sleep(1)

    print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

    if __name__ == '__main__':

    main()

    执行如下:

    add_func2,第96次,g_num等于197

    add_func2,第97次,g_num等于198

    add_func2,第98次,g_num等于199

    add_func2,第99次,g_num等于200

    2个线程对同一个全局变量操作之后的最终结果是:200

    [root@server01 many_task]#

    两个线程虽然执行很快,但是g_num恰好就是100+100=200的结果,是正确的。不过,这个数量少,可能看不出问题来。

    测试示例2

    [root@server01 many_task]# vim test7.py

    def work1(num):

    global g_num

    for i in range(num):

    g_num += 1

    print("----in work1, g_num is %d---"%g_num)

    def work2(num):

    global g_num

    for i in range(num):

    g_num += 1

    print("----in work2, g_num is %d---"%g_num)

    print("---线程创建之前g_num is %d---"%g_num)

    t1 = threading.Thread(target=work1, args=(10000000,))

    t1.start()

    t2 = threading.Thread(target=work2, args=(10000000,))

    t2.start()

    while len(threading.enumerate()) != 1:

    time.sleep(1)

    print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

    运行如下:

    [root@server01 many_task]# python test7.py

    ---线程创建之前g_num is 0---

    ----in work1, g_num is 11977799---

    ----in work2, g_num is 19108796---

    2个线程对同一个全局变量操作之后的最终结果是:19108796

    [root@server01 many_task]#

    正确的结果应该是:20000000

    结论

    如果多个线程同时对同一个全局变量操作,会出现资源竞争问题,从而数据结果会不正确。

    展开全文
  • 主要介绍了Python 多线程共享变量的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • python多线程可以使任务得到并发执行,但是有时候在执行多次任务的时候,变量出现“意外”。 import threading,time n=0 start=time.time() def b1(num): global n n=n+num n=n-num def b2(num): for i in ...
  • 多线程-共享全局变量import threadingimport timeg_num = 200def test1():global g_numfor i in range(5):g_num += 1print("--test1, g_num = %d--" % g_num)def test2():global g_numprint("--test2, g_num = %d--...

    多线程-共享全局变量

    import threading

    import time

    g_num = 200

    def test1():

    global g_num

    for i in range(5):

    g_num += 1

    print("--test1, g_num = %d--" % g_num)

    def test2():

    global g_num

    print("--test2, g_num = %d--" % g_num)

    if __name__ == "__main__":

    print("--执行线程之前, g_num = %d--" % g_num)

    t1 = threading.Thread(target=test1)

    t1.start()

    # 延时一会儿,确保线程t1中的事情能做

    time.sleep(1)

    t2 = threading.Thread(target=test2)

    t2.start()

    运行结果:

    --执行线程之前, g_num = 200--

    --test1, g_num = 205--

    --test2, g_num = 205--

    在上面的程序中。 test1函数

    循环五次,每次将 g_num

    全局变量加一并打印 g_num

    的值,在 test2函数

    中仅仅打印 g_num

    的值。在t1线程中执行test1函数,在t2线程中执行test2函数,并在执行t2线程之前,延时一秒中来保证t1线程执行完毕。

    列表当作实参传递到线程中

    import threading

    import time

    def test1(nums):

    nums.append(54)

    print("--test1, nums=", nums)

    g_nums = [1, 8, 9]

    def test2(nums):

    # 确保test1中执行完毕

    time.sleep(1)

    print("--test2, nums=", nums)

    if __name__ == "__main__":

    t1 = threading.Thread(target=test1, args=(g_nums,))

    t1.start()

    t2 = threading.Thread(target=test2, args=(g_nums,))

    t2.start()

    运行结果:

    --test1, nums= [1, 8, 9, 54]

    --test2, nums= [1, 8, 9, 54]

    总结

    在一个进程内的所有线程共享全局变量,很方便在多个线程间共享数据

    缺点就是,线程是对全局变量随意修改可能造成多线程之间对全局变量的混乱(即线程非安全)

    多线程-共享全局变量问题

    多线程开发可能遇到的问题

    假设两个线程t1和t2都要对全局变量g_num(默认是0)进行加1运算,t1和t2都各对g_num加10次,g_num的最终的结果应该为20。

    但是由于是多线程同时操作,有可能出现下面情况:

    在g_num=0时,t1取得g_num=0。此时系统把t1调度为”sleeping”状态,把t2转换为”running”状态,t2也获得g_num=0

    然后t2对得到的值进行加1并赋给g_num,使得g_num=1

    然后系统又把t2调度为”sleeping”,把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。

    这样导致虽然t1和t2都对g_num加1,但结果仍然是g_num=1

    测试1

    import threading

    import time

    g_num = 0

    def test1(num):

    global g_num

    for i in range(num):

    g_num += 1

    print("--test1, g_num = %d--" % g_num)

    def test2(num):

    global g_num

    for i in range(num):

    g_num += 1

    print("--test2, g_num = %d--" % g_num)

    if __name__ == "__main__":

    print("--创建线程之前, g_num = %d--" % g_num)

    t1 = threading.Thread(target=test1, args=(100,))

    t1.start()

    t2 = threading.Thread(target=test2, args=(100,))

    t2.start()

    while len(threading.enumerate()) != 1:

    time.sleep(1)

    print("最终结果为:g_num=%d" % g_num)

    运行结果:

    --创建线程之前, g_num = 0--

    --test1, g_num = 100--

    --test2, g_num = 200--

    最终结果为:g_num=200

    测试2

    在测试1的基础上,向test1和test2方法传入的参数的值为:9999999

    运行结果:

    --创建线程之前, g_num = 0--

    --test1, g_num = 13554011--

    --test2, g_num = 13571206--

    最终结果为:g_num=13571206

    很显然,期待的结果为:9999999 + 9999999 = 19999998,而运行结果为:13571206。

    展开全文
  • 一、多线程共享全局变量首先我们来回忆下在函数中修改全局变量的情况。在一个函数中,对全局变量进行修改的时候,到底是否需要使用 global 进行说明,要看是否对全局变量的执行指向进行了修改。如果修改了执行指向,...

    一、多线程共享全局变量

    首先我们来回忆下在函数中修改全局变量的情况。

    在一个函数中,对全局变量进行修改的时候,到底是否需要使用 global 进行说明,要看是否对全局变量的执行指向进行了修改。

    如果修改了执行指向,即让全局变量指向了一个新的地方,那么必须使用 global。

    如果仅仅是修改了指向的空间中的数据,此时不是必须要使用 global。

    我们来看一个例子,在这个例子中,让一个子线程对全局变量 +1 操作,另一个子线程只打印全局变量,看看数据是否共享。

    from threading import Thread

    import time

    g_num = 100

    def work1():

    global g_num

    g_num += 1

    print("----in work1, g_num is %d---" % g_num)

    def work2():

    print("----in work2, g_num is %d---" % g_num)

    def main():

    print("---线程创建之前g_num is %d---" % g_num)

    t1 = Thread(target=work1)

    t1.start()

    # 延时一会,保证t1线程中的事情做完

    time.sleep(1)

    t2 = Thread(target=work2)

    t2.start()

    time.sleep(1)

    print("---线程创建之后g_num is %d---" % g_num)

    if __name__ == "__main__":

    main()

    如果子线程2打印出来的结果是100,说明全局变量不共享。

    如果子线程2打印出来的数据是101,说明全局变量共享。

    运行结果:

    ---线程创建之前g_num is 100---

    ----in work1, g_num is 101---

    ----in work2, g_num is 101---

    ---线程创建之后g_num is 101---

    上面的例子说明,多线程是共享全局变量的。

    二、列表当做实参传递到线程中

    在上面,我们验证了多线程之间是共享全局变量的。

    我们也可以将变量当作实参传递到线程中,来验证多线程中是共享数据的。

    from threading import Thread

    import time

    def work1(nums):

    nums.append(44)

    print("----in work1---", nums)

    def work2(nums):

    print("----in work2---", nums)

    g_nums = [11, 22, 33]

    t1 = Thread(target=work1, args=(g_nums,))

    t1.start()

    # 延时一会,保证t1线程中的事情做完

    time.sleep(1)

    t2 = Thread(target=work2, args=(g_nums,))

    t2.start()

    运行结果:

    ----in work1--- [11, 22, 33, 44]

    ----in work2--- [11, 22, 33, 44]

    那为什么多个线程之间要共享全局变量,有什么好处么?

    因为多任务往往配合使用。

    在一个进程内的所有线程共享全局变量,就可以很方便在多个线程间共享数据。

    缺点就是,线程是对全局变量随意修改可能造成多线程之间对全局变量的混乱(即线程非安全)。

    以上就是python 多线程共享全局变量的优劣的详细内容,更多关于python 多线程共享全局变量的资料请关注聚米学院其它相关文章!

    展开全文
  • 本篇文章给大家带来的内容是关于Python多线程共享全局变量的实现代码,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。在一个进程内的所有线程共享全局变量。但多线程对全局变量的更改会导致变量...
  • 今天小编就为大家分享一篇python进阶之多线程对同一个全局变量的处理方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 多线程环境下,每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好,因为局部变量只有线程自己能看见,不会影响其他线程,而全局变量的修改必须加锁。但是局部变量也有问题,就是在函数调用的...
  • Python 多线程-共享全局变量问题

    千次阅读 2019-08-07 18:49:02
    多线程-共享全局变量问题 多线程可能遇到的问题 假设有两个线程t1和t2,都要对一个变量g_num进行运算(+1),两个线程t1和t2分别对g_num各加10次,g_num的最终结果? import threading import time g_num = 0 def ...
  • python多线程-共享全局变量

    千次阅读 2019-08-22 23:53:32
    多线程-共享全局变量 from threading import Thread import time g_num = 100 def work1(): global g_num for i in range(3): g_num += 1 print("----in work1, g_num is %d---"%g_num) def work2()...
  • 一、多线程共享全局变量 首先我们来回忆下在函数中修改全局变量的情况。 在一个函数中,对全局变量进行修改的时候,到底是否需要使用 global 进行说明,要看是否对全局变量的执行指向进行了修改。 如果修改了执行...
  • 1、第一个代码是多线程的简单使用,编写了线程如何执行函数和类。 import threading import time class ClassName(threading.Thread): """创建类,通过多线程执行""" def run(self): for i in range(5): ...
  • 今天小编就为大家分享一篇python多线程共享变量的使用和效率方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧 python多线程可以使任务得到并发执行,但是有时候在执行多次任务的时候,变量...
  • 主要介绍了浅谈python多线程和多线程变量共享问题介绍,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Manager支持的类型有 list,dict,Namespace,Lock,RLock,Semaphore,...而触发__setitem__方法比较直接的办法就是增加一个中间变量,如同在C语言中交换两个变量的值一样: int a=1;int b=2;int tmp=a;a=b;b=tmp; python
  • 多线程都是在同一个进程中运行的。因此在进程中的全局变量所有线程都是可共享的。这就造成了一个问题,因为线程执行的顺序都是无序的,有可能会造成数据错误,代码如下: #!/usr/bin/env python #-*- coding:utf-8 -...
  • 1、共享变量 #通过共享变量 import time import threading url_list = [] def get_detail_html(): global url_list while True: if len(url_list): url_list.pop() print("get detai...
  • 当一个进程的线程需要访问同一个变量的时候,就产生了共享变量的问题。可以通过加锁或者信号灯的方式,解决此问题。 解决互斥 - 方法1:加锁 锁LOCK: 通常对互斥资源进行加锁,在加锁之后,可以对互斥资源...
  • 之前我们遇到过,如果线程共同对某个数据修改,则可能出现不可预料的结果,为了保证数据的正确性,需要对线程进行同步。 解决线程同时修改全局变量的方式 我们先把上次那个问题再看下。 import t

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,373
精华内容 16,149
关键字:

python多线程共享变量