Java在同步块中调用其他方法

Question

I have written a worker class looking like this:

public final class Worker
{
  private static final int    LOOP_COUNT    = 10;
  private static final int    COMPUTE_COUNT = 1000;
  private static final Random RANDOM        = new Random();
  private static final int    BUFFER_SIZE   = 4;

  /**
   * do a little bit of calculation and write the thread’s name to stdout
   */
  public static void  doSomething()
  {
    for (int i = 0; i < LOOP_COUNT; i++)
    {
      System.out.println("Thread " + Thread.currentThread().getName()
          + " doing something: " + i);
      System.out.flush();

      for (int j = 0; j < COMPUTE_COUNT; j++)
      {
        final byte[] buffer = new byte[BUFFER_SIZE];
        RANDOM.nextBytes(buffer);
        final BigInteger b1 = new BigInteger(buffer);
        b1.pow(128);
      }
    }
  }
}

Afterwards I call the worker with following class:

public class SynchronizedMultiMethod
{
  public synchronized void methodOne()  
  {
    Worker.doSomething();
  }

  public void methodTwo()
  {
    Worker.doSomething();
  }
}

I start two new threads in my main-method and call the two methods in SynchronizedMultiMethod:

public class Main {

    public static void main(String[] args) throws InterruptedException
      {
        final SynchronizedMultiMethod sync = new SynchronizedMultiMethod();

        final Thread t1 = new Thread()
          {
            public void run()
            {   
                sync.methodOne();
            }
          };

        final Thread t2 = new Thread()
          {
            public void run()
            {

              sync.methodTwo();
            }
          };

        t1.start();
        t2.start();
      }
}

If I execute this code, I get this output:

Thread Thread-1 doing something: 0
Thread Thread-0 doing something: 0
Thread Thread-1 doing something: 1
Thread Thread-1 doing something: 2
Thread Thread-1 doing something: 3
Thread Thread-0 doing something: 1
Thread Thread-0 doing something: 2
Thread Thread-1 doing something: 4
...

I'm a little bit confused because I thaught that if I use synchronized on an instance method, the whole instance is blocked for other threads and will be released by leaving the synchronized block. If I use a second synchronized on methodTwo(), it works fine:

Thread Thread-0 doing something: 0
Thread Thread-0 doing something: 1
Thread Thread-0 doing something: 2
Thread Thread-0 doing something: 3
Thread Thread-0 doing something: 4

Can anybody tell me how it works? thx!

Answer 1

You are mistaken about the meaning and usage of synchronized . If you declare a method synchronized , it is functionally equivalent to putting a synchronized(this) {...} block around the entire contents of the method body. This interacts with other synchronized methods of the same object, and with other blocks synchronized on the same object, but it has no effect on other code.

In particular, methods and blocks that are not synchronized on the same object -- or are not synchronized at all -- are not excluded from running concurrently with a synchronized method of a given object. Thus, sync.methodTwo() , which is not synchronized, can run concurrently with sync.MethodOne() . One of many ways to prevent this would be to make SynchronizedMultiMethod.methodTwo() synchronized as well.

Answer 2

Synchronized keyword in java is used in two ways 1.At Instance level 2.At Class level

In the instance level ,we are passing the instance in the synchronized method like synchronized(this)

• public synchronized void methodOne(Worker sWorker) { sWorker.doSomething(); }

In above code we are just passing the instance which we are willing to synchronized.