Is it possible to access static methods of a class by multiple object instances simultaneously?

Question

Example:

ThisClass.staticMethod(Object... parameters);

will be accessed by multiple instances of other objects and simultaneously.

Will there be any dependencies with this other objects when they are using the same static method at the same time?

Answer 1

Only if the method uses static Objects or the arguments are shared by the other instances.

Example: Math.max(int a, int b) is a static method but does not use any static objects, so there are no dependencies.

Example 2: Here all invocations share the same result variable, two parallel calls to staticMethod can cause wrong results.

private static int result = 0;
private static int staticMethod(Object... args)
{
      result = args.length;
      //Do Something
      return result;
}

Example 3: This one is Thread safe if none of the arguments are shared, each invocation has its own instance of result.

private static int staticMethod(Object... args)
{
    int result = 0;
    result = args.length;
    //Do something
    return result;
}

Example 4: This uses the class as a lock to prevent parallel access to the class functions. Only one call to staticMethod executes all others wait

private static int result = 0;
private static synchronized int staticMethod(Object... args)
{
      result = args.length;
      //Do Something
      return result;
}

Answer 2

A code fragment running concurrently by multiple threads has the potential of causing race conditions, regardless of where this code is placed (static/non-static method).

You must make sure that the data manipulated by the code tolerates concurrent accesses, and synchronize the code properly if needed.

Answer 3

Obviously, all users of the method depend on the class, if this is what you mean.

Moreover, if they are really calling the method simultaneously (i.e. from multiple threads), you may get concurrency problems, depending on what the method actually does. Show us the code, and we may be able to tell more.