标签: parallel-processing

Microsoft .NET 4.0为其框架引入了新的"并行增强".我想知道使用标准System.Threading函数的应用程序与新的并行增强功能之间的区别.

是否有一些替代品map并行评估列表？我不需要它懒惰.

类似的东西:pmap :: (a -> b) -> [a] -> [b]让我pmap expensive_function big_list拥有100%的核心.

以下代码片段之间是否有任何区别？如果是这样,什么？

myList.AsParallel().ForAll(i => { /*DO SOMETHING*/ });

和

Parallel.ForEach(mylist, i => { /*DO SOMETHING*/ });

主线程是否会等待所有子线程完成？在MVC应用程序中,如果我在控制器操作中进行并行处理,主线程完成后子线程会发生什么.他们会被中止还是会在主线完成后完成？

如何在julia中将数据从一个处理器移动到另一个处理器？

说我有一个阵列

a = [1:10]

或者其他一些数据结构.将它放在所有其他可用处理器上的正确方法是什么,以便它们可以作为相同的变量名在这些处理器上使用？

是否有理论分析可以解释mapreduce可以解决哪些问题？

除非我非常误解MSBuild,否则任务按文档顺序执行,它们出现在"Target"节点中.

我希望能够指定两个任务(例如xcopy任务)可以并行运行.我期待有一个'并行'任务或什么......？

我正在使用BackgroundWorker更新,ObservableCollection但它给出了这个错误:

"这种类型CollectionView不支持SourceCollection从与Dispatcher线程不同的线程对其进行更改 ."

用最少的工作量来解决这个问题的最佳和最优雅的方法是什么.我不想写低级别的基于锁的多线程代码.

我在网上看到了一些解决方案,但它们已有几年的历史了,所以不确定解决这个问题的最新共识是什么.

JDK 8 EA现在已经出局了,我只是想习惯lambda和新的Stream API.我试图用并行流对列表进行排序,但结果总是错误的:

import java.util.ArrayList;
import java.util.List;

public class Test
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<>();
        list.add("C");
        list.add("H");
        list.add("A");
        list.add("A");
        list.add("B");
        list.add("F");
        list.add("");

        list.parallelStream() // in parallel, not just concurrently!
            .filter(s -> !s.isEmpty()) // remove empty strings
            .distinct() // remove duplicates
            .sorted() // sort them
            .forEach(s -> System.out.println(s)); // print each item
    }
}

OUTPUT:

C
F
B
H
A

请注意,每次输出都不同.我的问题是,这是一个错误吗？或者不可能并行排序列表？如果是这样,那么为什么JavaDoc没有声明呢？最后一个问题,还有另一个操作,其输出会根据流类型而有所不同吗？

我一直在做一些调查,看看我们如何创建一个贯穿树的多线程应用程序.

为了找到如何以最佳方式实现这一点,我创建了一个运行在我的C:\ disk中的测试应用程序并打开所有目录.

class Program
{
    static void Main(string[] args)
    {
        //var startDirectory = @"C:\The folder\RecursiveFolder";
        var startDirectory = @"C:\";

        var w = Stopwatch.StartNew();

        ThisIsARecursiveFunction(startDirectory);

        Console.WriteLine("Elapsed seconds: " + w.Elapsed.TotalSeconds);

        Console.ReadKey();
    }

    public static void ThisIsARecursiveFunction(String currentDirectory)
    {
        var lastBit = Path.GetFileName(currentDirectory);
        var depth = currentDirectory.Count(t => t == '\\');
        //Console.WriteLine(depth + ": " + currentDirectory);

        try
        {
            var children = Directory.GetDirectories(currentDirectory);

            //Edit this mode to switch what way of parallelization it should use
            int mode = 3;

            switch (mode) …

我已经阅读过这个和这个问题,但仍然怀疑Stream.skipJDK作者是否打算观察到这种行为.

让我们简单输入数字1..20:

List<Integer> input = IntStream.rangeClosed(1, 20).boxed().collect(Collectors.toList());

现在让我们创建一个并行流,以不同的方式结合unordered()使用skip()并收集结果:

System.out.println("skip-skip-unordered-toList: "
        + input.parallelStream().filter(x -> x > 0)
            .skip(1)
            .skip(1)
            .unordered()
            .collect(Collectors.toList()));
System.out.println("skip-unordered-skip-toList: "
        + input.parallelStream().filter(x -> x > 0)
            .skip(1)
            .unordered()
            .skip(1)
            .collect(Collectors.toList()));
System.out.println("unordered-skip-skip-toList: "
        + input.parallelStream().filter(x -> x > 0)
            .unordered()
            .skip(1)
            .skip(1)
            .collect(Collectors.toList()));

过滤步骤在这里基本没什么,但为流引擎增加了更多的难度:现在它不知道输出的确切大小,因此关闭了一些优化.我有以下结果:

skip-skip-unordered-toList: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
// absent values: 1, 2
skip-unordered-skip-toList: …