Tag: 并发性

在实践中，消息传递并发语言如何比共享内存并发语言更好: 我一直是一个Java开发人员多年，但直到我开始进行Android开发，从来没有处理太多的并发问题，突然开始发现“应用程序没有响应”和明显的死锁情况。这让我意识到理解和debugging这些并发问题是多么困难。 Scala和Go等新语言如何提高并发性？他们如何更容易理解，他们如何防止并发错误？有人可以提供真实世界的例子，certificate优势？

核心数据的NSPrivateQueueConcurrencyType和线程之间的共享对象: iOS 5引入了一种新方法，通过使用NSPrivateQueueConcurrencyType初始化MOC，然后在performBlock:执行获取，在后台线程上快速获取数据performBlock: 核心数据的经验之一就是你不能在线程/队列之间共享pipe理对象。执行块是否仍然如此performBlock: ？是以下几点： [context performBlock:^{ // fetch request code NSArray *results = [context executeFetchRequest:request error:nil]; dispatch_async(dispatch_get_main_queue(), ^(void) { Class *firstObject = [results objectAtIndex:0]; // do something with firstObject }); }]; 仍然无法接受，因为我在bg队列和主队列之间共享我的结果数组/对象？我仍然需要使用托pipe对象ID来做到这一点？

我如何在Scala中执行多个任务？: 我有50,000个任务，想用10个线程执行它们。在Java中，我应该创buildExecuters.threadPool（10）并传递runnable，然后等待处理所有。据我所知，Scala对于这个任务特别有用，但我无法在文档中find解决scheme。

我怎么知道这个C＃方法是线程安全的？: 我正在创build一个ASP.NETcaching项删除事件的callback函数。文档说，我应该调用一个对象的方法或我知道会存在的调用（将在范围内），如静态方法，但它说我需要确保静态是线程安全的。第一部分：我可以做些什么事情让事情变得不安全？第2部分：这是否意味着，如果我有 static int addOne(int someNumber){ int foo = someNumber; return foo +1; } 我叫Class.addOne（5）; 和Class.addOne（6）; 同时，我可能得到6或7返回取决于哪些调用集foo第一？（即比赛条件）

直接可访问的数据结构Java: 我有以下情况：一个只能扩展的数据结构（我只能在尾部添加东西）我需要能够跟踪我已经看到了哪些元素（我有一个索引，理想情况下，我想能够从这个特定的元素开始遍历列表）我希望读取永不被阻塞，并添加新的元素只locking队列的尾部，而不是整个队列这是一个由多个线程严重修改的结构。什么是最好的数据结构呢？ ArrayList 。这将是理想的能够直接访问使用索引看到的最后一个元素，但它会导致并发修改exception。我可以使它同步，但希望避免locking（或从最后一个元素除外的任何locking，因为它是唯一可能有并发写入添加新元素） ConcurrentLinkedQueue 。这将解决我的并发问题，但有问题，我将不得不存储迭代的当前位置，而不是一个整数索引。这有一个问题，即它返回一个弱一致的迭代器，它不能保证从迭代器创build以来已经添加到列表中的新对象（source：javadoc）以索引作为关键字的ConcurrentHashMap 。这样做的好处是我可以直接访问与正确索引相对应的数据，但是有一个问题，就是没有一个“getNext”操作符，它允许我有效地遍历索引到索引+1等元素 vector这将解决我的大部分问题，允许一些不会抛出并发修改exception，并允许直接访问。但是，由于所有方法都是同步的，与arrays列表相比，性能差。鉴于我只想扩展结构，而不是在中间插入logging，所以我不愿意去做这个重量级的解决scheme，在这个解决scheme中，读取也会受到性能的影响（但是，由于我的用例，元素的索引从来没有真正改变，所以没有必要同步读取不是尾巴）自定义数据结构：保存一个我想存储的对象的数组和一个指向这个数组尾部的指针（最后一个元素集），当插入一个新的对象时，locking尾部和尾部指向的对象。当对象超出当前大小时，执行locking大小调整操作。什么是最好的战略/更有效的实施？

提高性能一致性的方法: 在以下示例中，一个线程正在通过消费者正在使用的ByteBuffer发送“消息”。最好的performance是非常好的，但不一致。 public class Main { public static void main(String… args) throws IOException { for (int i = 0; i < 10; i++) doTest(); } public static void doTest() { final ByteBuffer writeBuffer = ByteBuffer.allocateDirect(64 * 1024); final ByteBuffer readBuffer = writeBuffer.slice(); final AtomicInteger readCount = new PaddedAtomicInteger(); final AtomicInteger writeCount = new PaddedAtomicInteger(); for(int […]

CopyOnWriteArrayList如何可以线程安全？: 我已经看了一下CopyOnWriteArrayList OpenJDK源代码，看起来所有的写操作都被相同的锁保护，读操作根本不受保护。据我所知，在JMM下，所有对variables（读取和写入）的访问都应该受到锁的保护，否则可能会发生重新sorting效应。例如， set(int, E)方法包含这些行（在locking下）： /* 1 */ int len = elements.length; /* 2 */ Object[] newElements = Arrays.copyOf(elements, len); /* 3 */ newElements[index] = element; /* 4 */ setArray(newElements); 另一方面get(int)方法只return get(getArray(), index); 。在我对JMM的理解中，这意味着如果语句1-4像1-2（新）-4-2（copyOf）-3一样被重新sorting， get可能会观察到数组处于不一致状态。我是否不正确地理解JMM，或者有什么解释说明为什么CopyOnWriteArrayList是线程安全的？

什么时候最好在Java中使用volatile布尔值而不是AtomicBoolean？: 我已经看过SO中的其他volatile和Atomicxxxx问题（包括这个），并且已经阅读了java.util.current.atomic的描述，对这些细微之处我还不太满意。如果我试图决定使用volatile boolean和AtomicBoolean ，是否有除AtomicBoolean提供的primefaces读取 – 修改 – 写入操作之间的实际差异？（比如compareAndSet()和getAndSet() ）假设我有 volatile boolean flag; 然后一个或多个线程设置标志（但不清除它）。如果我有一个线程读取标志，如果设置，做一个动作，然后清除标志，是不是足够的？ AtomicBoolean的成本比volatile boolean更高内存空间性能命中（ volatile boolean似乎需要内存屏蔽， AtomicBoolean似乎需要内存屏蔽+根据java.util.current.atomic描述对CAS操作进行一些次要locking）我的直觉是和AtomicBoolean一起去，并且是安全的，但我想知道是否有使用volatile boolean的情况（例如，如果我有成千上万的实例，性能是一个问题）。

与Alamofire的NSURLSession并发请求: 我正在使用我的testing应用程序遇到一些奇怪的行为。我有大约50个同时发送到同一个服务器的GET请求。服务器是一个embedded式服务器上的一小部分硬件资源非常有限。为了优化每个请求的性能，我configuration一个Alamofire.Manager实例如下： let configuration = NSURLSessionConfiguration.defaultSessionConfiguration() configuration.HTTPMaximumConnectionsPerHost = 2 configuration.timeoutIntervalForRequest = 30 let manager = Alamofire.Manager(configuration: configuration) 当我通过manager.request(…)发送请求时，它们会以2对的forms发送（如预期的那样，使用Charles HTTP Proxy进行检查）。奇怪的是，所有在第一个请求30秒内没有完成的请求，由于同时超时而被取消（即使它们还没有被发送）。下面是一个展示行为的例子：这是一个预期的行为，我怎样才能确保请求不会得到超时之前，他们甚至被发送？非常感谢！

在产卵和查杀过程中，F＃真的比Erlang快吗？: 更新：这个问题包含一个错误，使基准毫无意义。我将尝试一个比较F＃和Erlang的基本并发function的更好的基准，并在另一个问题上询问结果。我正在尝试去理解Erlang和F＃的性能特点。我发现Erlang的并发模型非常吸引人，但是由于互操作性的原因，我倾向于使用F＃。尽pipe开箱即用的F＃并没有提供像Erlang的并发原语这样的东西 – 从我所知道的asynchronous和MailboxProcessor只涵盖了Erlang很好的一小部分 – 我一直在试图理解F＃中可能的性能明智的。在Joe Armstrong编程的Erlang书中，他指出在Erlang中进程非常便宜。他使用（大致）下面的代码来certificate这个事实： -module(processes). -export([max/1]). %% max(N) %% Create N processes then destroy them %% See how much time this takes max(N) -> statistics(runtime), statistics(wall_clock), L = for(1, N, fun() -> spawn(fun() -> wait() end) end), {_, Time1} = statistics(runtime), {_, Time2} = statistics(wall_clock), lists:foreach(fun(Pid) -> […]