blocks|key|1931902|text|锁定一个索引意味着您可以跟踪哪个线程正在访问数组的哪一部分。跟踪这个在读线程和写线程之间共享的信息，意味着您对这个信息有一个锁。所以，你最终还是得到了一个全局锁。在这种情况下，我认为最有效的方法是：-使用读取器/写入器锁-或者将大型数组划分为几个子集，每个子集使用不同的锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1931903|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|$]]

Locking one index implies that you can keep track of which thread is accessing what part of the array. Keeping track of this information, which is shared between the reading and the writing thread, implies that you have one lock around this information. So, you still end up with a global lock.
In this situation, I think that the most efficient approaches are:
- using a reader/writer lock
- or dividing the big array into a few subsets, each subset using a distinct lock.

blocks|key|3868609|text|如果这是C%2B%2B，我建议你使用STL容器。std::vector或者其他适合你工作的东西。它们速度快，使用方便，没有内存泄漏。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3868610|如果你想自己做所有的事情，那么当然有一种方法是使用单个互斥锁(这是不好的)。或者，您可以对整个数组使用一些reader+writer+thingy。|3868611|我认为用自己的锁使数组线程的每个元素都安全是不可行的！那会吞噬你的记忆。检查链接，有3个不同输出的解决方案。对它们进行测试，并为您的情况使用最好的。(不要认为“好吧，我认为我的程序需要读者偏好算法”。试着在你的系统中使用它并决定。因为我们有时真的不能假设这样的事情)|3868612|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Readers-writers_problem^0|K|B|0|1H|K|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@$9|V|A|W|1|X]]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

If this is C++ i suggest you to use STL containers. <code>std::vector</code> or something else which suits your job. They are fast, easy to use, no memory leaks.

If you want to do it all by your self, then of course one method will be to use a single mutex ( which is bad ).
or you can use some <a href="http://en.wikipedia.org/wiki/Readers-writers_problem" rel="nofollow">reader writer thingy</a> for the whole array.

I think its not feasible to make each element of an array thread safe with its own lock!! that would eat your memory. Check the link and there are 3 solutions with different out comes. Test them out and use the best for your case. ( don't think like "ok i think my program needs the readers preference algorithm". try using it in your system and decide. because we really cant assume such things sometimes )

blocks|key|1931936|text|除非您在实际的运行条件下进行分析，否则没有办法知道什么是最优的。我建议实现一个类似数组的类，其中您可以将不同数量的元素锁定在组中。然后微调这些组的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1931937|另一种选择是使用active+object将所有读/写操作入队。这将使所有访问都是顺序的，这意味着您可以使用非并发数组类型来存储数据。这将需要在幕后使用某种并发队列数据结构。|offset|length|1931938|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Active_object^0|0|8|D|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]]]]

There is no way of knowing what will be optimal unless you profile under realistic running conditions. I would suggest implementing an array-like class, where you can lock a varying number of elements in groups. Then you fine-tune the size of these groups.

Another option would be to enqueue all read/write operations using an <a href="http://en.wikipedia.org/wiki/Active_object" rel="nofollow">active object</a>. This would make all access sequential, and means you could use a non-concurrent array type to store the data. It would require some sort of concurrent queue data structure under the hood.

I'm working on some code that has a global array that can be accessed by two threads for reading writing purposes.

There will be no batch processing where a range of indexes are read or written, so I'm trying to figure out if I should lock the entire array or only the array index I am currently using.

The easiest solution would be to consider the array a CS and put a big fat lock around it, but can I avoid this and just lock an index?

Cheers.

Multithreading - In an array what should I protect?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在编写一些具有全局数组的代码，该数组可以被两个线程访问以实现读写目的。不会有读取或写入一系列索引的批处理，所以我正在尝试确定是否应该锁定整个数组，还是只锁定当前使用的数组索引。最简单的解决方案是将数组视为CS，并在其周围放置一个大的大锁，但我是否可以避免这种情况，只锁定一个索引？干杯。

问多线程-在数组中，我应该保护什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问多线程-在数组中，我应该保护什么？EN