Is the plinq that returning the tolist() is thread safe?

Question

0.00/5 (No votes)

See more:

In the below below code UE is dictionary and bg is the list.
I am using PLINQ to get the values from the dictionary and returning the list.
Is the below code is thread safe?

TIA

What I have tried:

t = UE.AsParallel().Where(x => bg.Contains(x.Key, StringComparer.OrdinalIgnoreCase)).Select(y => y.Value).Distinct().ToList();

Posted 7-Mar-16 9:28am

MYQueries1

Updated 7-Mar-16 14:20pm

Add a Solution

2 solutions

Solution 1

As long as you're only reading and not modifying values anything is thread safe.

Posted 7-Mar-16 9:47am

Sascha Lefèvre

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Matt T Heffron · Accepted Answer · 2016-03-07T14:20:00

Sascha is correct about thread safety.
However, if you are using the .AsParallel() to improve performance, you're going about it incorrectly!

Since bg is a List<string>, the .Contains() is a very poor way to check for membership in the list. It is O(n) (where n is bg.Length). So the overall query is O(n*m) (where m is UE.Count).
Instead, you should make a HashSet<string> from bg and check for membership in the set. That is O(1), making the overall query directly proportional to UE.Count.

Using the HashSet is about 100 times faster (on my system) than the parallelized scan of bg.
Parallelizing the HashSet version actually slows it down, presumably due to the parallelization setup and context switching and coordination overhead.
Here's my testing code:

C#

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace ConsoleApplication10
{
  class Program
  {
    static void Main(string[] args)
    {
      Random rand = new Random();
      Stopwatch swp = new Stopwatch();
      Stopwatch swh = new Stopwatch();
      Stopwatch swph = new Stopwatch();
      bool tail = false;
      const int count = 200;
      for (int i = 0; i <= count; i++)
      {
        // Populate the collections
        Dictionary<string, int> UE = new Dictionary<string, int>();
        List<string> bg = new List<string>();
        int roff = rand.Next(1000);
        foreach (var item in Enumerable.Range(roff, 10000))
        {
          string key = item.ToString("D");
          UE.Add(key, item % (roff + 500));
          if (item % 10 == 0)
            bg.Add(key);
        }

        // skip timing the first time through so we're sure the JITTER isn't included.
        if (tail)
          swp.Start();
        List<int> tp = UE.AsParallel().Where(x => bg.Contains(x.Key, StringComparer.OrdinalIgnoreCase)).Select(y => y.Value).Distinct().ToList();
        if (tail)
          swp.Stop();

        if (tail)
          swh.Start();
        HashSet<string> hs = new HashSet<string>(bg, StringComparer.OrdinalIgnoreCase);
        List<int> th = UE.Where(x => hs.Contains(x.Key)).Select(y => y.Value).Distinct().ToList();
        if (tail)
          swh.Stop();

        if (tail)
          swph.Start();
        HashSet<string> hps = new HashSet<string>(bg, StringComparer.OrdinalIgnoreCase);
        List<int> tph = UE.AsParallel().Where(x => hps.Contains(x.Key)).Select(y => y.Value).Distinct().ToList();
        if (tail)
          swph.Stop();

        tail = true;

        // so GC of per-timing-iteration garbage isn't included in timing
        UE = null;
        bg = null;
        hs = null;
        hps = null;
        GC.Collect();
      }

      Console.WriteLine("Parallel processing: {0:F2} ticks (avg)", swp.ElapsedTicks / (double)count);
      Console.WriteLine("HashSet processing: {0:F2} ticks (avg)", swh.ElapsedTicks / (double)count);
      Console.WriteLine("Parallel & HashSet processing: {0:F2} ticks (avg)", swph.ElapsedTicks / (double)count);
      Console.WriteLine("Return to exit");
      Console.ReadLine();
    }
  }
}