相关疑难解决方法(0)

我有这个:

d1 = OrderedDict([('a', '1'), ('b', '2')])

如果我这样做:

d1.update({'c':'3'})

然后我明白了:

OrderedDict([('a', '1'), ('b', '2'), ('c', '3')])

但我想要这个:

[('c', '3'), ('a', '1'), ('b', '2')]

没有创建新词典.

我想知道Python内置容器(list,vector,set ...)是否是线程安全的？或者我是否需要为共享变量实现锁定/解锁环境？

我想在python中包装特定类的每个方法,并且我想通过最低限度地编辑类的代码来实现.我该怎么办呢？

Python中的线程模块提供了两种锁:公共锁和可重入锁.在我看来,如果我需要锁,我应该总是喜欢RLock而不是Lock; 主要是为了防止死锁情况.

除此之外,我看到两点,何时更喜欢Lock over RLock:

• RLock具有更复杂的内部结构,因此可能具有更差的性能.
• 由于某种原因,我想阻止线程通过锁递归.

我的推理是否正确？你能指出其他方面吗？

我是python的新手,目前正在尝试学习线程.我厌倦了使用锁来使我的资源成为线程安全的,因为它们本身并不依赖于资源,所以每次我的代码与资源交互时,我都会忘记获取和/或释放它们.相反,我希望能够"包装"(或装饰？)一个对象,以便它的所有方法和属性getter/setter都是原子的.这样的事情:

state = atomicObject(dict())

# the following is atomic/thread-safe
state["some key"] = "some value"

这可能吗？如果是这样,那么实施它的"最佳实践"方式是什么？

编辑:如何使内置容器(集,dicts,列表)线程安全可用的上述问题的一个很好的答案？.然而; 正如abarnert和jsbueno都证明的那样,我提出的解决方案(自动锁定)通常不是一个好主意,因为确定原子操作的适当粒度需要一些智能,并且可能很难(或不可能)正确自动化.

问题仍然存在,锁不以任何方式绑定到它们要保护的资源,因此我的新问题是:将锁与对象关联起来的好方法是什么？

提出的解决方案#2:我想可能有一种方法可以将锁绑定到一个对象,这样在没有首先获取锁的情况下尝试访问该对象会引发错误,但我可以看到这可能会变得棘手.

编辑:以下代码与问题无关.我发布它是为了证明我曾尝试自己解决问题并在发布此问题之前迷路了.

为了记录,我编写了以下代码,但它不起作用:

import threading    
import types
import inspect

class atomicObject(object):

    def __init__(self, obj):
        self.lock = threading.RLock()
        self.obj = obj

        # keep track of function handles for lambda functions that will be created
        self.funcs = []

        # loop through all the attributes of the passed in object
        # and create wrapped versions of each attribute …

我是Python的多线程新手,目前正在编写一个附加到csv文件的脚本.如果我要将多个线程提交给一个concurrent.futures.ThreadPoolExecutor将行附加到csv文件的行.如果附加是这些线程唯一与文件相关的操作,我该怎么做才能保证线程安全？

我的代码的简化版本:

with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    for count,ad_id in enumerate(advertisers):

        downloadFutures.append(executor.submit(downloadThread, arguments.....))
        time.sleep(random.randint(1,3)) 

我的线程类是:

def downloadThread(arguments......):

                #Some code.....

                writer.writerow(re.split(',', line.decode()))

我应该设置一个单独的单线程执行程序来处理写入,还是担心我是否只是附加？

编辑:我应该详细说明,当写入操作发生时,下一次附加文件之间的分钟数差别很大,我只关心在测试我的脚本时没有发生这种情况,我宁愿为此加以覆盖.

我想知道dict.update()是否是python线程安全的.我已经阅读了相关的问题,但它们都没有完全解决我的问题.

我的问题非常具体和简单.例如,我已经有一本本地字典d2.我只需要更新全局字典d,d2如下所示.d从空开始并用不同的线程填满.在d2每个线程可能有重叠的条目d(不要以为这个问题).它是线程安全的吗？

import dis

def f(d):
    d2 = {1:2, 3:4}
    d.update(d2)

print(dis.dis(f))

字节码如下所示:

 10           0 LOAD_CONST               1 (2)
              2 LOAD_CONST               2 (4)
              4 LOAD_CONST               3 ((1, 3))
              6 BUILD_CONST_KEY_MAP      2
              8 STORE_FAST               1 (d2)

 11          10 LOAD_FAST                0 (d)
             12 LOAD_ATTR                0 (update)
             14 LOAD_FAST                1 (d2)
             16 CALL_FUNCTION            1
             18 POP_TOP
             20 LOAD_CONST               0 (None)
             22 RETURN_VALUE

它看起来像是16 CALL_FUNCTION更新字典的原子函数.那么它应该是线程安全的吗？