如何在Java中控制对对象的多线程访问？

Question

i am writing server in java. for purpose of this question lets say the following: server can accept multiple clients, each one in its own thread. each client once connected calls one method on the server which draws some graphic object. only one instance of the method must be active at once. in case this method is active at the same time at multiple threads, the result will be that drawn object would be scrambled. it takes around 100ms for method to execute. to prevent multiple threads from accessing the method at once, i added static field of the class which once this method is called is updated to mark that method is active, and once method completes it updates the property to mark that method is inactive. each thread calls this method, but first thing method does is check the value of that field, and if it indicates that another instance of the method is already executing, it puts this thread to sleep for short time, and once it wakes up, it periodically checks the value of the field, and once value indicates another thread is complete executing this method, then another thread continues, updates the value of this field to indicate it is executing and then executes, and again updates it to indicate it finished executing. this goes for each thread once it calls the method.

this approach improved cases where collision occurs, but it did not eliminated it completely. this is because it takes time since some thread detects that another thread is finished executing until it updates the parameter to indicate that it is now executing again. this time is very short, less than a 1ms, but still it is possible for collision to occur, that is for more than one thread to detect that method is not executing. since it is possible that since one thread detects method is not executing until it marks it as executing that in the mean time another thread also detects this method as not executing.

i know this might seam confusing, so i prepared a small example for you to understand me better:

public class some_class_acessed_by_multiple_threads
{
    private static volatile java.lang.Boolean lock_access;
    static 
    {
        lock_access = false;
    }
    public static void some_method_called_by_multiple_threads() throws java.lang.InterruptedException
    {
        //detection.
        while(lock_access)
        {
            java.lang.Thread.sleep(64);
        }
        //locking access to other threads.
        lock_access =true;
        some_method_which_must_not_be_active_in_multiple_threads_at_once();
        //once execution completes, unlocking access to other threads.
        lock_access =false;
    }
    private static void some_method_which_must_not_be_active_in_multiple_threads_at_once()
    {
        //draw some object.
    }
}

if i use logic like in this example above to prevent access to method by more than one thread at once, it works great for small number of threads. if 1, 2, 5, 10, 50 clients is connected, collisions not occur.

but if i have lets say 1000 clients (what means 1000 threads fighting to access this method for drawing objects) or more, collisions still start to happen very often. as you can see from my example, from the time line "detection" finishes executing until the time line "locking access..." finishes executing, it passes some time. probably time in microseconds, but still some time passes.

so my question to you is, do you have any suggestions on how i can improve my code above, so that not even 1000 threads fighting for access to the method for drawing objects can cause collision?

thank you for any suggestions.

Answer 1

Have you tried the built-in synchronized java keyword?

private static void some_method_which_must_not_be_active_in_multiple_threads_at_once()

becomes

private static synchronized void some_method_which_must_not_be_active_in_multiple_threads_at_once()

This way, each thread has to kave a token to run this method. Tell us if it helps!

Answer 2

you should use synchronization... simply synchronize the method

public static synchronized void some_method_called_by_multiple_threads() throws java.lang.InterruptedException

synchronization simply means one thread can access the method at a time. refer the API documentations for more details