标签: concurrent-programming

parallel_for_each 具有以下形式:

Concurrency::parallel_for_each(start_iterator, end_iterator, function_object);

但parallel_for也有类似的形式:

Concurrency::parallel_for(start_value, end_value, function_object);

那么究竟是什么之间的差异Concurrency::parallel_for,并Concurrency::parallel_for_each在编程中使用多个内核算法？

我在多线程应用程序中常用的数据结构是ConcurrentHashMap,我想在其中保存一组共享相同键的项.安装特定键值的第一项时会发生此问题.

我一直使用的模式是:

final ConcurrentMap<KEYTYPE, Set<VALUETYPE>> hashMap = new ConcurrentHashMap<KEYTYPE, Set<VALUETYPE>>();
// ...
Set<VALUETYPE> newSet = new HashSet<VALUETYPE>();
final Set<VALUETYPE> set = hashMap.putIfAbsent(key, newSet)
if (set != null) {
  newSet = set;
}
synchronized (newSet) {
  if (!newSet.contains(value)) {
    newSet.add(value);
  }
}

这种操作有更好的模式吗？这是否是线程安全的？是否有更好的课程用于内心而Set不是java.util.HashSet？

我正在阅读"Clojure的喜悦",以及关于paralellization,功能和部分的部分pvalues,pmap并pcalls简要介绍了如何使用每个部分.下面是给出的例子pvalues和pcalls:

(defn sleeper [s thing] (Thread/sleep (* 1000 s)) thing)

(pvalues
  (sleeper 2 :1st)
  (sleeper 3 :2nd)
  (keyword "3rd"))

(pcalls
  #(sleeper 2 :1st)
  #(sleeper 3 :2nd)
  #(keyword "3rd"))

我理解两者之间的技术差异 - pvalues需要计算可变数量的"值",而pcalls并行地调用"任意数量的不带参数的函数".在这两种情况下,都会返回结果的延迟序列.

我的问题基本上是,你何时会使用一个与另一个？似乎唯一的语义差异是你#在每个参数之前粘贴一个pcalls,将它变成一个匿名函数.因此,纯粹从保存击键和使用更简单的代码的角度来看,使用它会不会更有意义pvalues？- 如果是这样,为什么甚至有pcalls功能？

我得到了pcalls,您可以替换一个引用函数的符号,但如果您想使用这样的函数pvalues,您可以将函数放在括号中,以便调用它.

我只是有点困惑,为什么Clojure有这两个相似的功能.有什么可以用一个而不是另一个吗？一些人为的例子可能会有所帮助.

我想写三个并发的例程,它们相互发送整数.现在,我的代码被正确编译,但是在第一次执行之后它会给出错误"所有goroutines都睡着了 - 死锁!".我试图找到错误,但我无法在代码逻辑中找到任何错误.任何人都可以帮我找到我的代码的错误.我的代码如下.提前致谢.

package main

import "rand"

func Routine1(command12 chan int, response12 chan int, command13 chan int, response13 chan int) {
    for i := 0; i < 10; i++ {
        y := rand.Intn(10)
        if y%2 == 0 {
            command12 <- y
        }

        if y%2 != 0 {
            command13 <- y
        }
        select {
        case cmd1 := <-response12:
            print(cmd1, " 1st\n")
        case cmd2 := <-response13:
            print(cmd2, " 1st\n")
        }
    }
    close(command12)
}

func Routine2(command12 chan int, response12 chan int, command23 chan …

我似乎无法找到支持简单的Remove()函数的.NET线程安全/并发集合,我可以在其中删除特定项目或传入谓词以根据该项目删除项目.我试过了:

BlockingCollection<T>
ConcurrentQueue<T>
ConcurrentStack<T>
ConcurrentBag<T>

有没有人知道支持这种行为的集合,还是我必须自己创建？

我希望能够从线程安全队列中获取下一个项目而不删除它,稍后如果满足某个条件,则继续删除它.

在许多网络文章中,函数式编程被表示为避免各种变量重新分配,因此仅推广"最终"变量,至少为了更好的阅读.

它们中的大多数都采用带有计数器变量递增的不良循环的样本.(就像着名的i++或者x = x + 1.这里有一篇鲍勃叔叔的文章说明:FP第1集

因此,这些文章表明,依靠可变变量经常导致副作用,特别是防止我们所谓的"参照透明度",因此,更难以构建在多线程或更好的多处理器上运行的程序.

我的问题是:众所周知,i++通常是一个线程LOCAL变量,因此即使并发处理也不会出现问题.

为什么选择一个像带有局部变量的循环这样的例子作为赋值的缺点,并且允许直接得出结论并发编程存在风险？这两件事与我严格无关.

为了更清楚,为什么不选择全局变量(或字段对象)的重新分配,这显然enemy是并发编程,而不像Java那样过度使用所有的锁定模板.

我真的认为这个循环示例并不是将函数式编程的好处传递给命令式程序员的最好例证.

此外,它导致与"noob"函数程序员混淆,因为Scala例如在List.scala类中使用了很多while循环模式:

override def take(n: Int): List[A] = {
    val b = new ListBuffer[A]
    var i = 0
    var these = this
    while (!these.isEmpty && i < n) {  
      i += 1   // reassignment here
      b += these.head
      these = these.tail
    }
    if (these.isEmpty) this
    else b.toList
  } 

无法理解并行计算列表元素的正确方法是什么,但是在不计算元素(并行)时阻塞主线程.使用案例:我有一个URL链接列表和一个简单的html页面解析器,我可以通过并行解析每个页面来减少从给定页面获取信息所需的时间,然后返回一个带有一些JSON数据的简单列表.

据我所知,我有两个选择:

与期货并行的方式

我有一个方法在Future中提取一些JSON数据:

def extractData(link: String): Future[JValue] = // some implementation

我只是将它映射到一个链接列表,其类型将是List [Future [JValue]]:

val res: List[Future[JValue]] = listOfLink.map(extractData)

如果我调用sequence(例如来自Scalaz或我自己的实现)遍历此列表并将其转换为Future[List[JValue]],则链接仍将按顺序处理,但是一个单独的线程,这将不会给我任何效率,导致我需要的结果得到一个List[JValue].

尝试使用ParSeq进行计算

在这个选项中,我有一个只提取数据的函数:

def extractData(link: String): JValue = // some implementation

但是这次打电话.par给集合:

val res: ParSeq[JValue] = listOfLinks.map(extractData)

但是这样我不太明白如何在不按顺序解析每个链接的情况下阻止主列表,而不会计算空洞列表

至于Akka,我只是不能在这里使用演员,所以只有Future或Par*

我只是听到并看到有人说scala是为MultiThread设计的,尽管它实际上是出于通用目的.

它声称"事情是,虽然你可以在Java中创建线程安全的类(如果你知道你正在做什么),Scala让它变得简单而自然."

事实上,AKKA和Lift是用scala编写的.(实际上是java和scala)

但java在java.util.concurrent的新包中也在这方面做了改进.那么为什么AKKA和Lift出生在JAVA？

也许你会说scala使java看起来像C. :-)

任何人都可以对此有更深入的了解或深入的想法？

我知道可以混合使用JAVA和scala.Scala能够无缝地调用Java代码.那么java有什么,scala也是如此.

但是scala真正改进了java还没有完成,不管语法不同？

只有一些设计像演员/代理或其他什么？(注意Actors/Agents无法解决MultiThread中的所有问题.)

或者scala编译器和采用一些函数式语言语法真的比java更重要或帮助吗？

我听到一些消息称scala将能够采用XText.为了能够利用XText编写线程逻辑,不确定这是否属实.

Scala看起来像是语言的混合物,使用这种方法可以更加可扩展地解决这方面的问题？

UPDATE

感谢您从不同角度出色的答案.我认为他们都非常好.无论你站在哪一边.

编辑

下面的主题(在一年前的SO中)询问了类似的事情."建设性"结论非常相似.但这一次,一些新的观点可能会出现,我要问的方式有点不同.仅供参考.

有关:

• Scala对Java进行并发编程有什么优势？

• Java并发:CAS与锁定

• Java和C/C++之间MultiThread方面的差异

• 功能编程的缺陷/缺点

其实我很感兴趣,有些人可以用一些全新的角度回答这个问题,这可以启发我的思想,提供一些未知的想法.

但由于没有建设性,它已经关闭了.:-)

我一直在获得并发修改异常

String[] permsList = Constants.CUST_MKT_PERMS_FIELDS;
String hiddenFieldVector = new Vector<String>(permsList.length);
Iterator<String> itr = hiddenFieldVector.iterator();

for(int i = 0; i < arrayLength; i++){    //arrayLength is never null or 0

    ...a lot of code...
    String target = fromDatabase();     //this is never null

   while(itr.hasNext() && hiddenFieldVector.contains(target)){
    hiddenFieldVector.remove(target);
    Logger.debug("itr.next() = " + itr.next());
   }

    ...a lot of code...
}

任何想法为什么？

当前解决方案

while(itr.hasNext() && hiddenFieldVector.contains(target) && (itr.next().equals(target))){
                        itr.remove();
                        Logger.debug("itr.next() = " + itr.next());
                    }

在Java中,我想做这样的事情:

   Object r = map.get(t);
   if (r == null) {
      r = create(); // creating r is an expensive operation.
      map.put(t, r);  
   }

现在,代码片段可以在多线程环境中执行. map可以是ConcurrentHashMap.

但是我如何使逻辑成为原子？

请不要像"同步"块那样给我一些简单的解决方案.我希望这个问题可以一劳永逸地解决.