这两者有什么区别？
比较的最佳方法是什么？
plinq 总是更好？
当我们使用 plinq ？
问问题
5797 次
5 回答
13
Linq 是一组协同工作以解决类似问题系列的技术 - 在所有这些技术中，您都有一个数据源（xml 文件或文件、数据库内容、内存中的对象集合）并且您想要检索部分或全部并以某种方式对其采取行动。Linq 致力于解决这组问题的共性，例如：
var brithdays = from user in users where
user.dob.Date == DateTime.Today && user.ReceiveMails
select new{user.Firstname, user.Lastname, user.Email};
foreach(bdUser in birthdays)
SendBirthdayMail(bdUser.Firstname, bdUser.Lastname, bdUser.Email);
以及等价物（使用传统 C# 语法显式使用 Linq 相关的类和方法）：
var birthdays = users
.Where(user => user.dob.Date == DateTime.Today)
.Select(user => new{user.Firstname, user.Lastname, user.Email});
foreach(bdUser in birthdays)
SendBirthdayMail(bdUser.Firstname, bdUser.Lastname, bdUser.Email);
无论是转换为数据库调用、解析 xml 文档还是搜索对象数组，这两个代码示例都可以工作。
唯一的区别是对象是什么类型users。如果它是一个列表、数组或其他可枚举的集合，它将是 linq-to-objects，如果它是 a System.Data.Linq.Table，它将是 linq to sql。前者会导致内存中的操作，后者会导致 SQL 查询，然后尽可能晚地将其反序列化为内存中的对象。
如果它是ParallelQuery- 通过调用.AsParallel内存中的可枚举集合产生的 - 那么查询将在内存中执行，并行化（大部分时间）以便由多个线程执行 - 理想情况下让每个核心忙于推进工作.
显然这里的想法是更快。当它运作良好时，它确实如此。
不过也有一些缺点。
首先，进行并行化总是有一些开销，即使在最终无法并行化的情况下也是如此。如果没有对数据进行足够的工作，那么这种开销将超过任何潜在的收益。
其次，并行处理的好处取决于可用的内核。如果查询最终不会阻塞 4 核机器上的资源，理论上你会得到 4 倍的加速（4 个超线程可能会给你更多甚至更少，但可能不是 8 倍，因为 hyper-线程将 CPU 的某些部分加倍并没有明显增加两倍）。对于单核上的相同查询，或者处理器亲和性意味着只有一个核可用（例如，处于“网络花园”模式的网络服务器），那么就没有加速。如果资源被阻塞，仍然会有收益，但收益取决于机器。
第三，如果有任何共享资源（可能正在输出一个集合结果）以非线程安全的方式使用，它可能会因不正确的结果、崩溃等而出现严重错误。
第四，如果以线程安全的方式使用共享资源，并且线程安全来自锁定，则可能存在足够的争用成为瓶颈，从而抵消并行化带来的所有好处。
第五，如果您有一台四核机器在四个不同的线程上运行或多或少相同的算法（可能是由于四个客户端而导致的客户端-服务器情况，或者在桌面情况下来自一组更高级别的类似任务）过程），那么他们已经充分利用了这些核心。将算法中的工作拆分以便在所有四个内核上进行处理意味着您已经从每个使用一个内核的四个线程转移到了争夺四个内核的 16 个线程。充其量它会是相同的，并且可能的开销会使情况变得更糟。
在很多情况下，它仍然可能是一个重大胜利，但以上内容应该清楚地表明它不会总是如此。
于 2011-12-17T21:03:23.577 回答
5
我还想知道何时使用 PLINQ 而不是 LINQ，所以我进行了一些测试。
摘要：在决定是使用 LINQ 还是 PLINQ 来运行查询时，有两个问题需要回答。
运行查询涉及多少次迭代（集合中有多少对象）？
一次迭代涉及多少工作？
除非 PLINQ 性能更高，否则请使用 LINQ。如果查询集合涉及太多迭代和/或每次迭代涉及太多工作，则 PLINQ 可能比 LINQ 性能更高。
但随后出现了两个难题：
- 多少次迭代算太多迭代？
- 多少工作是太多工作？
我的建议是测试您的查询。使用 LINQ 测试一次，使用 PLINQ 测试一次，然后比较两个结果。
测试 1：通过增加集合中的对象数量来增加查询中的迭代次数。
初始化 PLINQ 的开销大约需要 20 毫秒。如果不利用 PLINQ 的优势，这是浪费时间，因为 LINQ 有 0 毫秒的开销。
每次迭代中涉及的工作对于每个测试总是相同的。这项工作保持在最低限度。
工作定义：将 int（集合中的对象）乘以 10。
在迭代 100 万个对象且每次迭代涉及最少的工作时，PLINQ 比 LINQ 快。尽管在专业环境中，我从未查询甚至初始化内存中包含 1000 万个对象的集合，因此这可能是 PLINQ 恰好优于 LINQ 的不太可能的情况。
╔═══════════╦═══════════╦════════════╗
║ # Objects ║ LINQ (ms) ║ PLINQ (ms) ║
╠═══════════╬═══════════╬════════════╣
║ 1 ║ 1 ║ 20 ║
║ 10 ║ 0 ║ 18 ║
║ 100 ║ 0 ║ 20 ║
║ 1k ║ 0 ║ 23 ║
║ 10k ║ 1 ║ 17 ║
║ 100k ║ 4 ║ 37 ║
║ 1m ║ 36 ║ 76 ║
║ 10m ║ 392 ║ 285 ║
║ 100m ║ 3834 ║ 2596 ║
╚═══════════╩═══════════╩════════════╝
测试 2：增加迭代中涉及的工作
我将集合中的对象数设置为始终为 10，因此查询涉及的迭代次数较少。对于每个测试，我增加了处理每个迭代所涉及的工作。
工作定义：将 int（集合中的对象）乘以 10。
增加工作的定义：增加迭代次数以将 int 乘以 10。
PLINQ 查询集合的速度更快，因为当工作迭代中的迭代次数增加到 1000 万时，工作显着增加，我得出结论，当单个迭代涉及这么多工作时，PLINQ 优于 LINQ。
此表中的“#Iterations”表示一个工作迭代中的迭代次数。请参阅下面的测试 2 代码。
╔══════════════╦═══════════╦════════════╗
║ # Iterations ║ LINQ (ms) ║ PLINQ (ms) ║
╠══════════════╬═══════════╬════════════╣
║ 1 ║ 1 ║ 22 ║
║ 10 ║ 1 ║ 32 ║
║ 100 ║ 0 ║ 25 ║
║ 1k ║ 1 ║ 18 ║
║ 10k ║ 0 ║ 21 ║
║ 100k ║ 3 ║ 30 ║
║ 1m ║ 27 ║ 52 ║
║ 10m ║ 263 ║ 107 ║
║ 100m ║ 2624 ║ 728 ║
║ 1b ║ 26300 ║ 6774 ║
╚══════════════╩═══════════╩════════════╝
测试1代码：
class Program
{
private static IEnumerable<int> _numbers;
static void Main(string[] args)
{
const int numberOfObjectsInCollection = 1000000000;
_numbers = Enumerable.Range(0, numberOfObjectsInCollection);
var watch = new Stopwatch();
watch.Start();
var parallelTask = Task.Run(() => ParallelTask());
parallelTask.Wait();
watch.Stop();
Console.WriteLine($"Parallel: {watch.ElapsedMilliseconds}ms");
watch.Reset();
watch.Start();
var sequentialTask = Task.Run(() => SequentialTask());
sequentialTask.Wait();
watch.Stop();
Console.WriteLine($"Sequential: {watch.ElapsedMilliseconds}ms");
Console.ReadKey();
}
private static void ParallelTask()
{
_numbers
.AsParallel()
.Select(x => DoWork(x))
.ToArray();
}
private static void SequentialTask()
{
_numbers
.Select(x => DoWork(x))
.ToArray();
}
private static int DoWork(int @int)
{
return @int * 10;
}
}
测试2代码：
class Program
{
private static IEnumerable<int> _numbers;
static void Main(string[] args)
{
_numbers = Enumerable.Range(0, 10);
var watch = new Stopwatch();
watch.Start();
var parallelTask = Task.Run(() => ParallelTask());
parallelTask.Wait();
watch.Stop();
Console.WriteLine($"Parallel: {watch.ElapsedMilliseconds}ms");
watch.Reset();
watch.Start();
var sequentialTask = Task.Run(() => SequentialTask());
sequentialTask.Wait();
watch.Stop();
Console.WriteLine($"Sequential: {watch.ElapsedMilliseconds}ms");
Console.ReadKey();
}
private static void ParallelTask()
{
_numbers
.AsParallel()
.Select(x => DoWork(x))
.ToArray();
}
private static void SequentialTask()
{
_numbers
.Select(x => DoWork(x))
.ToArray();
}
private static int DoWork(int @int)
{
const int numberOfIterations = 1000000000;
for (int i = 0; i < numberOfIterations; i++)
{
@int = @int * 10;
}
return @int;
}
}
于 2018-07-23T13:15:07.790 回答
2
Plinq 是 Linq 的并行版本。一些查询可以在多个线程上执行，然后 PLinq 会提高性能。
但是，其他查询不能并行执行，否则会给出错误的结果。因此，您应该为每个查询决定何时使用 PLinq，并确保性能确实有所提高。
MSDN上有很多关于它的文档。
于 2011-12-16T22:01:30.970 回答
0
考虑在使用PLINQ时避免使用匿名类型，因为根据Joe Albahari 在 C# 中的线程：
匿名类型（作为类，因此是引用类型）会产生基于堆的分配和后续垃圾收集的成本。
(...)
基于堆栈的分配是高度可并行化的（因为每个线程都有自己的堆栈），而所有线程必须竞争同一个堆——由单个内存管理器和垃圾收集器管理。
于 2013-03-19T11:58:57.693 回答
0
PLINQ 可以通过更有效地使用主机上的所有可用内核来显着提高 LINQ to Objects 查询的速度。这种提高的性能为桌面带来了高性能计算能力。
于 2020-01-30T13:54:03.623 回答