Java Thread：(1) synchronization

第二版，1999年、第三版，2004年，可对照看。

一个类中的多个synchronized的方法：针对当前对象，同一时间多个线程只能执行其中的一个synchronized的方法。因为锁是针对对象的，并且每个对象只有一个锁token。

静态方法的synchronized同步锁被称为class lock(只是一种概念，实际上加锁的是一个静态对象？)：静态方法中传入实例对象引用，依然可以继续调用对应实例的同步方法。因为这是两把不同的锁。

第一版本BusyFlag——

public class BusyFlag {

    protected Thread busyflag = null;
    protected int busycount = 0;

    public void getBusyFlag() {
        while (!tryGetBusyFlag()) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {}
        }
    }

    public synchronized boolean tryGetBusyFlag() {
        if (busyflag == null) {
            busyflag = Thread.currentThread();
            busycount = 1;
            return true;
        }
        if (busyflag == Thread.currentThread()) {
            busycount++;
            return true;
        }
        return false;
    }
    public synchronized void freeBusyFlag () {
        if (getBusyFlagOwner() == Thread.currentThread()) {
            busycount--;
            if (busycount == 0)
                busyflag = null;
        }
    }
    public synchronized Thread getBusyFlagOwner() {
        return busyflag;
    }
}

• synchronized关键字可以赋予整个方法，也可以赋予代码块——使用哪种方式取决于个人选择，只要避免死锁问题即可
• freeBusyFlag()方法和getBusyFlagOwner()方法都添加了synchronized关键字；并且前者方法体中还调用了后者。

这种情况并不会造成死锁(后者不需要等待前者释放锁之后再执行)。实际上，如果当前线程已经获取了锁，是不需要在等待锁被释放，然后再去获取一次。所以从freeBusyFlag()方法中调用getBusyFlagOwner()方法没有问题。
引申含义是，如果开始执行同步方法时没有进行获取锁的操作的话，执行完同步方法也就不存在释放锁的动作。