类中同步方法被调用，其他方法是否可以同时被调用

    毕业初期，面试时经常被问到一个问题：一个类中同步方法被调用时，它的其他方法是否可以同时被调用？记得当时看过面试宝典，答案是否，不能被调用。但是其实这个答案是错误的。
正确的回答应该是该类中其他同步方法不能被同时调用，但非同步方法可以被调用。下面给出例子。
Business.java

package thread;

public class Business
{
    
    public synchronized void methodA() throws InterruptedException
    {
        Thread.sleep(10000);
        System.out.println("I am method A, I am a synchronized method");
    }
    
    public void methodB()
    {
        System.out.println("I am not a synchronized method, check if i can be called when the a synchronized method are called");
    }
    
    public synchronized void methodC()
    {
        System.out.println("I am a synchronized method, check if i can be called when the a synchronized method are called");
    }
}

Thread1.java

package thread;

public class Thread1 implements Runnable
{
    private Business bus;
    public Thread1(Business b)
    {
        this.bus = b;
    }
    @Override
    public void run()
    {
        try
        {
            bus.methodA();
        }
        catch (InterruptedException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

Thread2.java

package thread;

public class Thread2 implements Runnable
{
    private Business bus;
    public Thread2(Business b)
    {
        this.bus = b;
    }
    @Override
    public void run()
    {
        bus.methodB();
    }

}

thread3.java

package thread;

public class Thread3 implements Runnable
{
    private Business bus;
    public Thread3(Business b)
    {
        this.bus = b;
    }
    @Override
    public void run()
    {
        bus.methodC();
    }

}

TestMain.java

package thread;

public class TestMain
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        Business b = new Business();
        Thread th1 = new Thread(new Thread1(b));
        Thread th2 = new Thread(new Thread2(b));
        Thread th3 = new Thread(new Thread3(b));
        th1.start();
        th2.start();
        th3.start();
    }

}

运行会发现methodB的会立即被执行，但是methodA会sleep 10s,然后跟着methodC执行。

其实很容易理解，用sychronized把methodA和methodC加锁，默认情况下sychronized是对当前class类对象加锁，相当于

    public void methodA() throws InterruptedException
    {
        synchronized(this)
        {
            Thread.sleep(10000);
            System.out.println("I am method A, I am a synchronized method");
        }
       
    }

 public void methodC()
    {
        synchronized(this)
        {
            System.out.println("I am a synchronized method, check if i can be called when the a synchronized method are called");
        }
        
    }

所以当methodA持有锁时methodC就不能拿到锁，故不能被调用，而methodB则不需要获取锁，故可以被执行

评论

4 楼 Alex__Liu 2013-06-04  

picasso.di 写道

感觉您关于同步方法的论述有一些问题，我的理解是，实例方法中加入sychronized关键字封锁的是this对象本身，而在静态方法中加入sychronized关键字封锁的就是类本身，您给的例子里，方法都是实例方法，所以sychronized是对this加锁，而不是对class加锁，如果您给的方法是static的，那么就是对class加锁了。如果我有说的不对的地方，请指正！

你是对的，我疏忽了，已更正，谢谢

3 楼 picasso.di 2013-06-04  

感觉您关于同步方法的论述有一些问题，我的理解是，实例方法中加入sychronized关键字封锁的是this对象本身，而在静态方法中加入sychronized关键字封锁的就是类本身，您给的例子里，方法都是实例方法，所以sychronized是对this加锁，而不是对class加锁，如果您给的方法是static的，那么就是对class加锁了。如果我有说的不对的地方，请指正！

2 楼 ifoggy 2013-06-04  

其实明白synchronized关键字的作用就比较容易理解了，synchronized默认是会所住类对象的内部锁，而非synchronized方法并不会加上这个锁，自然可以被额外的线程调用执行。

1 楼 teasp 2013-06-04  

面试宝典上的错误一堆一堆的的。