Question

假设一个类SomeClass带有private static字段，如下所示。使用lock同步对该字段的访问。

private static SomeClass _instance
private static object _sync = new object();

public static SomeClass Instance 
{
    get 
    {
        lock (_sync)
        {
            if (_instance == null)
            {
                _instance = Create();
            }
            return _instance;   
        }
    }
}

当来自不同线程的另一个代码将尝试将此变量的值设置为例如null使用 reflection ，lock会阻止这种情况，让反射调用等到锁定被释放吗？

例如像这样的东西：

Type type = typeof(SomeClass);
string fieldName = "_instance";
object value = null;
FieldInfo field = type.GetField(fieldName, true);
field.SetValue(null, value);

Answer 1

否，锁定不会阻止任何未通过锁定相同资源进行的访问。由于反射不会通过lock，因此您将获得竞争条件。这是我的意思（与您的代码略有不同，但仍然做同样的事情）→

void SetOne(){
    lock (_sync){
         critical_element = SOME_VALUE;
     }
}

void SetTwo(){
   critical_element = SOME_ANOTHER_VALUE;
}

上面肯定有比赛条件。

这是我对OP问题的理解。我认为OP希望使用Singleton模式，这是一个非常不错且线程安全的实现。您也不需要处理锁。但是，某些不良用户可能仍会使用反射来设置背景字段。

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy = new Lazy<Singleton>(() => new Singleton());

    public static Singleton Instance { get { return lazy.Value; } }

    private Singleton(){}
}

将锁定以防止通过反射进行更改

1 个答案: