blocks|key|825872|text|默认情况下，Python中的许多操作都是线程安全的，所以一个标准的字典应该是可以的(至少在某些方面)。这主要归功于GIL，它将有助于避免一些更严重的线程问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825873|这里有一个可能有用的列表：http://coreygoldberg.blogspot.com/2008/09/python-thread-synchronization-and.html。|offset|length|825874|虽然这些操作的原子性质只是意味着，如果有两个线程同时访问一个字典，则不会有完全不一致的状态。这样你就不会有一个损坏的值。但是，您(与大多数多线程编程一样)不能依赖这些原子操作的特定顺序。|825875|所以长话短说...|825876|如果您有相当简单的需求，并且不关心写入缓存的内容的顺序，那么您可以使用字典，并且知道您将始终获得一致/未损坏的值(它可能已经过期)。|825877|如果你想确保读写的一致性，那么你可能想看看Django的本地内存缓存：|825878|http://code.djangoproject.com/browser/django/trunk/django/core/cache/backends/locmem.py|825879|它使用读/写锁进行锁定。|825880|entityMap|0|LINK|mutability|MUTABLE|url|http://coreygoldberg.blogspot.com/2008/09/python-thread-synchronization-and.html|1^0|0|D|28|0|0|0|0|0|0|0|2F|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]|Z|$5|U|V|W|A|$X|O]]]]

Well a lot of operations in Python are thread-safe by default, so a standard dictionary should be ok (at least in certain respects). This is mostly due to the GIL, which will help avoid some of the more serious threading issues.

There's a list here: <a href="http://coreygoldberg.blogspot.com/2008/09/python-thread-synchronization-and.html" rel="noreferrer">http://coreygoldberg.blogspot.com/2008/09/python-thread-synchronization-and.html</a> that might be useful.

Though atomic nature of those operation just means that you won't have an entirely inconsistent state if you have two threads accessing a dictionary at the same time. So you wouldn't have a corrupted value. However you would (as with most multi-threading programming) not be able to rely on the specific order of those atomic operations.

So to cut a long story short...

If you have fairly simple requirements and aren't to bothered about the ordering of what get written into the cache then you can use a dictionary and know that you'll always get a consistent/not-corrupted value (it just might be out of date).

If you want to ensure that things are a bit more consistent with regard to reading and writing then you might want to look at Django's local memory cache:

<a href="http://code.djangoproject.com/browser/django/trunk/django/core/cache/backends/locmem.py" rel="noreferrer">http://code.djangoproject.com/browser/django/trunk/django/core/cache/backends/locmem.py</a>

Which uses a read/write lock for locking.

blocks|key|3146217|text|每个请求的线程数通常不是一个好主意。如果您的服务器遇到了负载的巨大峰值，它将使服务器瘫痪。考虑使用一个线程池，它可以在使用高峰时增长到有限的大小，并在负载较轻时缩小到较小的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3146218|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Thread per request is often a bad idea. If your server experiences huge spikes in load it will take the box to its knees. Consider using a thread pool that can grow to a limited size during peak usage and shrink to a smaller size when load is light.

blocks|key|5401962|text|您可能希望改用memcached。它非常快，非常稳定，非常流行，有很好的python库，如果你需要，它将允许你成长为分布式缓存：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5401963|http://www.danga.com/memcached/|offset|length|5401964|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|V|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

You probably want to use memcached instead. It's very fast, very stable, very popular, has good python libraries, and will allow you to grow to a distributed cache should you need to:

<a href="http://www.danga.com/memcached/" rel="nofollow noreferrer">http://www.danga.com/memcached/</a>

blocks|key|3991445|text|存根()要点1.+GIL在这里对您没有帮助，一个名为“存根”的(非线程安全)缓存的示例如下|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3991446|stubs+=+{}

def+maybe_new_stub(host):
++++"""+returns+stub+from+cache+and+populates+the+stubs+cache+if+new+is+created+"""
++++if+host+not+in+stubs:
++++++++stub+=+create_new_stub_for_host(host)
++++++++stubs[host]+=+stub
++++return+stubs[host]|code-block|syntax|javascript|3991447|可能发生的情况是，Thread1调用maybe_new_stub('localhost')，它发现缓存中还没有这个键。现在我们切换到Thread2，它调用相同的maybe_new_stub('localhost')，并且它也知道密钥不存在。因此，两个线程都调用create_new_stub_for_host并将其放入缓存中。|CODE|3991448|map本身受到GIL的保护，所以我们不能通过并发访问来破坏它。然而，缓存的逻辑不受保护，因此我们最终可能会创建两个或更多存根，并将除一个存根之外的所有存根都丢弃在地板上。|3991449|根据程序的性质，您可能不需要全局缓存。这样的共享缓存会强制所有线程之间进行同步。出于性能方面的原因，最好使线程尽可能独立。我相信我确实需要它，实际上你可能不需要。|3991450|要点3.你可以使用一个简单的锁。我从https://codereview.stackexchange.com/questions/160277/implementing-a-thread-safe-lrucache中得到了灵感，并提出了以下建议，我相信这些建议可以安全地用于我的目的|3991451|import+threading

stubs+=+{}
lock+=+threading.Lock()


def+maybe_new_stub(host):
++++"""+returns+stub+from+cache+and+populates+the+stubs+cache+if+new+is+created+"""
++++with+lock:
++++++++if+host+not+in+stubs:
++++++++++++channel+=+grpc.insecure_channel('%25s:6666'+%25+host)
++++++++++++stub+=+cli_pb2_grpc.BrkStub(channel)
++++++++++++stubs[host]+=+stub
++++++++return+stubs[host]|3991452|点4.最好使用现有的库。我还没有找到任何我准备担保的东西。|3991453|entityMap|0|LINK|mutability|MUTABLE|url|https://codereview.stackexchange.com/questions/160277/implementing-a-thread-safe-lrucache^0|3|5|0|0|I|R|28|R|3M|O|0|0|0|0|4|I|2H|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@$9|1A|A|1B|B|M]|$9|1C|A|1D|B|M]|$9|1E|A|1F|B|M]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1G|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1H|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|T|3|U|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|1P|8|@$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]]]

Point 1. GIL does not help you here, an example of a (non-thread-safe) cache for something called "stubs" would be

<pre><code>stubs = {}

def maybe_new_stub(host):
 """ returns stub from cache and populates the stubs cache if new is created """
 if host not in stubs:
 stub = create_new_stub_for_host(host)
 stubs[host] = stub
 return stubs[host]
</code></pre>

What can happen is that Thread 1 calls <code>maybe_new_stub('localhost')</code>, and it discovers we do not have that key in the cache yet. Now we switch to Thread 2, which calls the same <code>maybe_new_stub('localhost')</code>, and it also learns the key is not present. Consequently, both threads call <code>create_new_stub_for_host</code> and put it into the cache.

The map itself is protected by the GIL, so we cannot break it by concurrent access. The logic of the cache, however, is not protected, and so we may end up creating two or more stubs, and dropping all except one on the floor.

Point 2. Depending on the nature of the program, you may not want a global cache. Such shared cache forces synchronization between all your threads. For performance reasons, it is good to make the threads as independent as possible. I believe I do need it, you may actually not.

Point 3. You may use a simple lock. I took inspiration from <a href="https://codereview.stackexchange.com/questions/160277/implementing-a-thread-safe-lrucache">https://codereview.stackexchange.com/questions/160277/implementing-a-thread-safe-lrucache</a> and came up with the following, which I believe is safe to use for my purposes

<pre><code>import threading

stubs = {}
lock = threading.Lock()


def maybe_new_stub(host):
 """ returns stub from cache and populates the stubs cache if new is created """
 with lock:
 if host not in stubs:
 channel = grpc.insecure_channel('%s:6666' % host)
 stub = cli_pb2_grpc.BrkStub(channel)
 stubs[host] = stub
 return stubs[host]
</code></pre>

Point 4. It would be best to use existing library. I haven't found any I am prepared to vouch for yet.

blocks|key|830043|text|对于你想要的线程安全对象，threading.local：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830044|from+threading+import+local

safe+=+local()

safe.cache+=+{}|code-block|syntax|javascript|830045|然后，您可以在具有线程安全性的safe.cache中放置和检索对象。|offset|length|style|CODE|830046|entityMap^0|0|0|F|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

For a thread safe object you want threading.local:

<pre><code>from threading import local

safe = local()

safe.cache = {}
</code></pre>

You can then put and retrieve objects in <code>safe.cache</code> with thread safety.

blocks|key|3146436|text|我不确定这些答案中有没有你想要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3146437|我也有类似的问题，我正在使用一个名为cachetools的简易lrucache替代品，它允许您传入一个锁以使其更安全。|offset|length|3146438|entityMap|0|LINK|mutability|MUTABLE|url|https://cachetools.readthedocs.io/en/stable/^0|0|I|A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I'm not sure any of these answers are doing what you want.
I have a similar problem and I'm using a drop-in replacement for lrucache called <a href="https://cachetools.readthedocs.io/en/stable/" rel="nofollow noreferrer">cachetools</a> which allows you to pass in a lock to make it a bit safer.

I have implemented a python webserver. Each http request spawns a new thread.
I have a requirement of caching objects in memory and since its a webserver, I want the cache to be thread safe. Is there a standard implementatin of a thread safe object cache in python? I found the following 

<a href="http://freshmeat.net/projects/lrucache/" rel="noreferrer">http://freshmeat.net/projects/lrucache/</a>

This does not look to be thread safe. Can anybody point me to a good implementation of thread safe cache in python?

Thanks!

python threadsafe object cache

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我已经实现了一个python have服务器。每个http请求产生一个新的线程。我有一个在内存中缓存对象的需求，因为它是一个the服务器，我希望缓存是线程安全的。python中是否有线程安全对象缓存的标准实现？我发现了以下内容这看起来不是线程安全的。有没有人能给我一个很好的python线程安全缓存的实现？谢谢!

问python threadsafe对象缓存
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python threadsafe对象缓存EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python threadsafe对象缓存
EN