我想使用Parallel.For或Parallel运行此常规循环 Parallel.ForEach<>
foreach (KeyValuePair<String, String> symbol in symbolsConfigured){..}
我一直在这样的其他地方使用-
Parallel.ForEach(sig.Products, dbp =>
{...}
但我想不出该如何写。
这行代码正在Parallel.For(... row => {code})中执行;
mechanismScores[row] += cellValue;
数组值和cellValue都是double类型.这个线程是安全的还是我需要做...
Interlocked.CompareExchange(ref mechanismScores[row],
mechanismScores[row] + cellValue, mechanismScores[row]);
或其他解决方案？
我是C#爱好者,我正在使用Parallel.ForEach方法.我试图使用以下代码在给定系统上显示环境变量:
IDictionary vars = Environment.GetEnvironmentVariables();
Parallel.ForEach(vars, (envVar) =>
{
Console.WriteLine("{0} = {1}", envVar.Key, envVar.Value);
});
但是我最终得到了这个错误:
错误3方法'System.Threading.Tasks.Parallel.ForEach <TSource>的类型参数(System.Collections.Concurrent.OrderablePartitioner <TSource>,System.Action <TSource,System.Threading.Tasks.ParallelLoopState,long>)'无法从使用中推断出来.尝试显式指定类型参数.
我很确定我错过了一个演员阵容,但无论我尝试过什么,都无法让它发挥作用.你能帮我吗？
我有~500个任务,每个任务需要约5秒,大部分时间浪费在等待远程资源回复上.我想定义应该自己生成的线程数(经过一些测试)并在这些线程上运行任务.当一个任务完成时,我想在可用的线程上生成另一个任务.
我发现System.Threading.Tasks最容易实现我想要的,但我认为不可能指定应该并行执行的任务数量.对于我的机器,它总是大约8(四核cpu).是否有可能以某种方式告诉应该并行执行多少任务？如果不是最简单的方法来实现我想要的东西？(我试过线程,但代码要复杂得多).我尝试增加MaxDegreeOfParallelism参数,但它只限制了最大数量,所以这里没有运气......
这是我目前的代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
private static List<string> _list = new List<string>();
private static int _toProcess = 0;
static void Main(string[] args)
{
for (int i = 0; i < 1000; ++i)
{
_list.Add("parameter" + i);
}
var w = new Worker();
var w2 = new StringAnalyzer();
Parallel.ForEach(_list, new ParallelOptions() { MaxDegreeOfParallelism = 32 }, item =>
{
++_toProcess;
string data = …我在工作负载中有一组可以并行运行的项目.有时只有1,有时会有很多.当我在一个大的工作负载上使用Parallel.ForEach时,它明显更快.所以它似乎是Parelle.ForEach的合适用途.
我已经读过,对于1或2的工作负载,最好不要将Parallel.ForEach放在它们上面.这是否意味着我必须用这种模式包装每个可变工作负载大小的Parallel.ForEach？
if (workItems.Count==1)
{
foreach (MyItem item in workItems)
{
bool failed = WorkItWorkIt(item);
}
}
else
{
Parallel.ForEach(workItems, (item, loopState) =>
{
bool failed = WorkItWorkIt(item);
});
}
我一直在重写一些流程密集型循环来使用TPL来提高速度.这是我第一次尝试线程,所以想要检查我正在做的是正确的方法.
结果很好 - DataTable从标准foreach循环转换为Parallel.ForEach循环时,处理1000行中的数据已将处理时间从34分钟减少到9分钟.对于此测试,我删除了非线程安全操作,例如将数据写入日志文件并递增计数器.
我仍然需要写回日志文件并增加一个计数器,所以我尝试实现一个包含streamwriter/increment代码块的锁.
FileStream filestream = new FileStream("path_to_file.txt", FileMode.Create);
StreamWriter streamwriter = new StreamWriter(filestream);
streamwriter.AutoFlush = true;
try
{
object locker = new object();
// Lets assume we have a DataTable containing 1000 rows of data.
DataTable datatable_results;
if (datatable_results.Rows.Count > 0)
{
int row_counter = 0;
Parallel.ForEach(datatable_results.AsEnumerable(), data_row =>
{
// Process data_row as normal.
// When ready to write to log, do so.
lock (locker)
{
row_counter++;
streamwriter.WriteLine("Processing row: {0}", row_counter); …我有一个字典,我想在foreach循环中修改它的值,但是,因为我的应用程序是时间关键的,我试图避免所有不必要的锁定开销.
var loopData = new Dictionary<int, List<string>>();
var results = new Dictionary<int, List<string>>();
/// loopData and results are both initialized
/// with same set of keys.
Parallel.ForEach(loopData, data =>
{
var list = data.Value;
/// manipulate list here
/// Is this safe?
results[data.Key] = list;
});
标记命令是否安全？即,无需锁定即可读/写字典的不同键值对.
注1:我知道并发集合名称空间及其所有宏观集合.另外我知道我可以简单地lock使用突出显示的命令来确保它的安全性.如前所述,我的目标是尽可能避免不必要的开销.
注2:在此链接中提出了类似的问题.在该问题中,容器的项目在Parallel.ForEach循环内被修改.然而,这里我们没有修改键值对,因此容器是完整的,只有被指向的数据被改变.这使得它与上述问题不同.
更新
ConcurrentDictionary会增加最少的开销,但我想避免它,如果这是安全的.c# multithreading dictionary concurrentdictionary parallel.foreach
我在每个循环停止并行时遇到问题.
我正在迭代一组从表中检索到的大约40.000个DataRows,当我在结果集中有100个项目时,我需要立即停止循环.问题是当我在ParallelLoopState上触发Stop方法时,迭代不会立即停止,导致我的结果集不一致(无论是少数项还是多项).
有没有办法确定,一旦我停止,我就会杀死所有线程？
List<DataRow> rows = new List<DataRow>(dataTable.Select());
ConcurrentDictionary<string, object> resultSet = new ConcurrentDictionary<string, object>();
rows.EachParallel(delegate (DataRow row, ParallelLoopState state)
{
if (!state.IsStopped)
{
using (SqlConnection sqlConnection = new SqlConnection(Global.ConnStr))
{
sqlConnection.Open();
//{
// Do some processing.......
//}
var sourceKey = "key retrieved from processing";
if (!resultSet.ContainsKey(sourceKey))
{
object myCustomObj = new object();
resultSet.AddOrUpdate(
sourceKey,
myCustomObj,
(key, oldValue) => myCustomObj);
}
if (resultSet.Values.Count == 100)
state.Stop();
}
}
});
我正在尝试提高计算图像平均值的方法的性能.
为此,我使用两个For语句来迭代所有图像,因此我尝试使用Parallel For来改进这一点,但结果并不相同.
我做错了吗？或者是什么导致了这种差异？
public static double MeanDN(this GrayImage image)
{
double mean = 0;
int totalPixels = image.Width * image.Height;
for (int i = 0; i < image.Height; i++)
for (int j = 0; j < image.Width; j++)
mean += (double)image[i, j] / totalPixels;
double parallelMean = 0;
Parallel.For(0, image.Height, i =>
{
for (int j = 0; j < image.Width; j++)
parallelMean += (double)image[i, j] / totalPixels;
});
return mean;
}
输出:
mean = 404.12
parallelMean = 148.8658
_logger.info("data size : "+saleData.size);
saleData.parallelStream().forEach(data -> {
SaleAggrData saleAggrData = new SaleAggrData() {
{
setCatId(data.getCatId());
setRevenue(RoundUpUtil.roundUpDouble(data.getRevenue()));
setMargin(RoundUpUtil.roundUpDouble(data.getMargin()));
setUnits(data.getUnits());
setMarginRate(ComputeUtil.marginRate(data.getRevenue(), data.getMargin()));
setOtd(ComputeUtil.OTD(data.getRevenue(), data.getUnits()));
setSaleDate(data.getSaleDate());
setDiscountDepth(ComputeUtil.discountDepth(data.getRegularPrice(), data.getRevenue()));
setTransactions(data.getTransactions());
setUpt(ComputeUtil.UPT(data.getUnits(), data.getTransactions()));
}
};
salesAggrData.addSaleAggrData(saleAggrData);
});
代码的问题是当我从DB获得响应时,并且在使用并行流进行迭代时,每次数据大小都不同,而使用顺序流时,它工作正常.
我不能使用顺序Stream因为数据很大并且需要时间.
任何领导都会有所帮助.