在同时调用方法时是否需要同步访问方法参数和本地？

Question

I have been writing a lot of code with static classes/methods that I believe will be called/executed simultaneously by multiple threads. So I am doing a lot of locking in my methods. I typically do this:

public static class MyThreadsafeMethods {

    private static Object staticLock1 = new Object();
    private static Object staticLock2 = new Object();

    public static string StaticMethod1(string param1, int param2) {
        lock (staticLock1) {
            var _param1 = param1;
            var _param2 = param2;

            //highly confidential business logic here

            return StaticMethod2(_param1, "Integer: " + _param2.ToString());
        }
    }

    public static string StaticMethod2(string param1, string param2) {
        lock (staticLock2) {
            var _param1 = param1;
            var _param2 = param2;

            //truly groundbreaking algorithm here

            return _param1 + " - " + _param2;
        }
    }
}

I am wondering two things:

1) I have thought that I need to be working with local "copies" of my parameters inside the "locked code"; because if another thread calls my method with different values for param1 and param2, that could mess up my processing. If I only work with variables that are declared/instantiated inside the locked code (ie _param1 and _param2 in the example above), then something could change the values of param1 and param2 (or send in references to different objects) and I am okay. But do I need to do that? Am I being unnecessarily paranoid?

2) I have decided that I don't want to instantiate my lock objects until I need them, because my collection of static locking objects is growing... So, I am now moving to doing this:

    private static Object staticLock1;

    public static string StaticMethod1(string param1, int param2) {
        lock(staticLock1 = staticLock1 ?? new Object()) {
            (...)
        }
    }

Is there any reason that instantiating my lock object the first time I need it is unsafe? Will using the assignment operator on my lock object in my lock statement somehow cause me problems or prevent the object from being properly locked?

Answer 1

1. What you have there won't make any difference at all - the arguments themselves cannot change after the call has been made, so it really does nothing. In your case with strings, it's perfectly safe seeing how string is immutable. When that isn't the case, it is possible that whatever is passed is altered somewhere else. In that case you'd have to make a real copy (ie not just copying the reference),

2. Consider the case where two threads arrive at lock(staticLock1 = staticLock1 ?? new Object()) at the same time. They could both see staticLock1 as null. So no that's not safe!

Answer 2

Your main confusion seems to be around what synchronization you need in order to safely call a static method concurrently.

Data races always arise because multiple threads access the same storage location in an unsynchronized way, and at least one of them is a writer. This basic rule is enough to reason about a lot of concurrency issues.

When you call a method, the arguments have different storage locations for each call. They are independent. Therefore, two threads calling the same method never race to access method arguments. You therefore never need to synchronize access to method arguments.

The same goes for locals. In fact, arguments have identical synchronization properties as locals have. They exist per call.

To answer your second issue: That is unsafe because two threads might lock on different objects. Also, you write to staticLock1 unsynchronized on multiple threads. I already explained that this is a data-race.

Answer 3

First: the overhead of creating an instance of Object is extremely small. Don't worry about it unless measurements show you that you should.

Just initialize like this:

private readonly static object staticLock1 = new Object();

The way you use the lock statement is not safe.

Secondly: I see no shared data in the methods so there is no reason to lock.

Finally: I would reconsider the design if it contains many static functions.