从多个异步方法同时执行相同的 function 会导致错误

Question

Here is a piece of code, where I try to execute different async methods, that need to be executed in specific order (the await , and Task.WhenAll() parts).

//Some other tasks before
Task<bool> taskIfcQuantityArea = Task.Run<bool>(() =>
{
    return this.addGroupStringToDictionary("IfcQuantityArea");
});
Task<bool> taskIfcQuantityLength = Task.Run<bool>(() =>
{
    return this.addGroupStringToDictionary("IfcQuantityLength");
});
Task<bool> taskIfcSiUnit = Task.Run<bool>(() =>
{
    return addGroupStringToDictionary("IfcSiUnit");
});
Task<bool> taskIfcPropertySingleValue = Task.Run<bool>(() =>
{
    return addGroupStringToDictionary("IfcPropertySingleValue");
});
//uses IfcPerson, IfcOrganization
Task<bool> taskIfcPersonAndOrganization = Task.Run<bool>(() =>
{
    return addGroupStringToDictionary("IfcPersonAndOrganization");
});
//uses IfcOrganization
Task<bool> taskIfcApplication = Task.Run(async () =>
{
    await taskIfcSiUnit;
    return addGroupStringToDictionary("IfcApplication");
});
//uses IfcSiUnit
Task<bool> taskIfcMeasureWithUnit = Task.Run(async () =>
{
    await taskIfcSiUnit;
    return addGroupStringToDictionary("IfcMeasureWithUnit");
});
//some other tasks after.

When I do that job synchronously, all works fine, but when I do it in async, I have some random errors. At every test, the errors come randomly. The only thing I see that could go wrong, is they all execute the same function addGroupStringToDictionary .

Here is the function:

private bool addGroupStringToDictionary(string typeName)
{
    //int processCount = await Task.Run<int>(() =>
    //{
    GroupedListStrings groupElt = this.listGrouppedStrings.FirstOrDefault(x => x.Type == typeName.ToUpper());
    if (groupElt != null)
    {
        List<string> listStringInGroup = groupElt.ListStrings;
        foreach (string line in listStringInGroup)
        {
            try
            {
                if(typeName== "IfcLocalPlacement($")
                {
                    typeName = "IfcLocalPlacement";
                }
                var type = Type.GetType("Ifc."+typeName);
                if (typeName == "IfcPropertySingleValue" || typeName == "IfcDirection" || typeName == "IfcSiUnit" || typeName == "IfcQuantityLength" || typeName == "IfcQuantityArea" || typeName == "IfcQuantityVolume" || typeName == "IfcQuantityWeight")
                {
                    try
                    {
                        object instance = Activator.CreateInstance(type, line);
                        this.addToListDictionary((IfcElement)instance);
                    }
                    catch
                    {

                    }
                }
                else if (typeName == "IfcOpeningElement")
                {
                    try
                    {
                        object instance = Activator.CreateInstance(type, line, this.listDictionaries, this.DictionaryBolts);
                        this.addToListDictionary((IfcElement)instance);
                    }
                    catch
                    {

                    }
                }
                else
                {
                    try
                    {
                        object instance = Activator.CreateInstance(type, line, this.listDictionaries);
                        this.addToListDictionary((IfcElement)instance);
                    }
                    catch
                    {

                    }
                }
            }
            catch
            {
                this.addError(line);
            }
        }
        this.listGrouppedStrings.Remove(groupElt);
        this.reportProgressImport();
    }
    //return 100;
    //});
    this.reportProgressImport();
    return true;
}

The catch got 1-2 times over a bit more than 1 million lines. At each test the errors come randomly. Is it possible that running the function simultaneously from several async methods, this is what causes the problem?

Here is the addToListDictionary function:

private void addToListDictionary(IfcElement elt)
{
    if(elt.ErrorFound)
    {
        this.listReadButError.Add(elt);
        return;
    }
    string type = elt.GetType().ToString();
    if (elt is IfcRepere)
    {
        type = "Ifc.IfcRepere";
    }
    else if (elt is IfcRepereType)
    {
        type = "Ifc.IfcRepereType";
    }
    else if (elt is IfcPhysicalSimpleQuantity)
    {
        type = "Ifc.IfcPhysicalSimpleQuantity";
    }
    else if (elt is IfcProfileDef)
    {
        type = "Ifc.IfcProfileDef";
    }
    else if (elt is IfcGeometricRepresentationContext)
    {
        type = "Ifc.IfcGeometricRepresentationContext";
    }
    GroupDictionary group = this.ListDictionaries.FirstOrDefault(x => x.Name == type);
    if(group==null)
    {
        group = new GroupDictionary { Name = type };
        this.ListDictionaries.Add(group);
    }
    group.ListElements[elt.ID] = elt;

    if (elt is IfcMechanicalFastener)
    {
        IfcMechanicalFastener bolt = (IfcMechanicalFastener)elt;
        this.DictionaryBolts[bolt.Tag] = bolt;
    }
    else if(elt is IfcProject)
    {
        this.listProjects.Add((IfcProject)elt);
    }
    else if(elt is IfcElementAssembly ifcAss)
    {
        this.DictionaryIfcElementAssemblies[ifcAss.Key] = ifcAss;
    }
}

Also some additive information about my ListDictionaries :

private List<GroupDictionary> listDictionaries = new List<GroupDictionary>();
public List<GroupDictionary> ListDictionaries { get { return this.listDictionaries; } set { this.listDictionaries = value; } }

And the class GroupDictionary

public class GroupDictionary
{
    string name { get; set; }
    public string Name { get { return this.name; } set { this.name = value; } }
    public ConcurrentDictionary<int, IfcElement> ListElements = new ConcurrentDictionary<int, IfcElement>();
    public GroupDictionary()
    {

    }
}

I made different GroupDictionary because as soon as I don't need one of them, I delete it to free space. I have one dictionary with IfcPoint , I need it to gt IfcPolyLine (lines), but when I finish to treat all objects using IfcPoint , I clear remove the corresponding GroupDictionary in order to free some memory.

Answer 1

You have a obvious thread-safety issues here (ie you are trying to perform some operation which is not thread safe from multiple threads at a time). There are multiple ways you can try tackling it - using lock 's, or some synchronization primitives . But in this case it seems that major source of issues is working with standard collections from multiple threads, which is not thread-safe (cause thread-safety usually comes with performance price and is not always needed). You can start from switching to appropriate collections from System.Collections.Concurrent namespace.

To go down deeper I recommend free e-book by Joseph Albahari Threading in C# .