Synchronized来修饰函数和Synchroinzed语句块在使用上的区别

在一个类中，两个不同函数使用

Synchronized来修饰函数f()

在函数g()中使用synchronized(syncObject)语句块

从输出中你能观察到两个方法同时运行,所以它们没有在对方的同步控制上阻塞.

package com.iwindyforest.syn;

/**
 * 把方法标记为synchronized : 一旦某个线程处于一个标记为synchronized的方法中,
 * 那么这个线程从该方法返回之前,其它要调用类中任何标记为synchronized的方法的线程都会被阻塞. 使用synchronized块 :
 * 这也被称为"同步控制块"(synchronized block),在进入此段代码前,
 * 必须得到syncObject对象的锁.如果其它线程已经得到这个锁,那么就得等到锁被释放以后,才能进入临界区.
 * 
 * @author chen.yinghua
 */
public class DualSyn
{
    private Object syncObject = new Object();

    public synchronized void f()
    {
        System.out.println("Inside f()");
        // Doesn't release lock
        try
        {
            Thread.sleep(1000);
        }
        catch(InterruptedException e)
        {
            throw new RuntimeException(e);
        }

        System.out.println("Leaving f()");
    }

    public void g()
    {
        synchronized(syncObject)
        {
            System.out.println("Insied g()");

            try
            {

                Thread.sleep(5000);
            }
            catch(InterruptedException e)
            {
                throw new RuntimeException(e);
            }

            System.out.println("Leaving g()");
        }
    }
}

package com.iwindyforest.syn;

/**
 * DualSync对象的f()方法在this上同步(通过在整个方法上同步),
 * g()的同步控制块在syncObject对象上同步.因此,两个同步控制相互独立. 在main()中通过创建调用f()的线程演示了这一点.
 * main()线程用来调用g(). 从输出中你能观察到两个方法同时运行,所以它们没有在对方的同步控制上阻塞.
 * 
 * @author chen.yinghua
 */
public class SyncObject
{
    public static void main(String[] args)
    {
        final DualSyn ds = new DualSyn();
        new Thread()
        {
            public void run()
            {
                ds.f();
            }
        }.start();

        ds.g();
    }
}