wait()方法与sleep()方法的不同之处在于，wait()方法会释放对象的“锁标志”。当调用某一对象的wait()方法后，会使当前线程暂停执行，并将当前线程放入对象等待池中，直到调用了notify()方法后，将从对象等待池中移出任意一个线程并放入锁标志等待池中，只有锁标志等待池中的线程可以获取锁标志，它们随时准备争夺锁的拥有权。当调用了某个对象的notifyAll()方法，会将对象等待池中的所有线程都移动到该对象的锁标志等待池。
sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入阻塞状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。

public class MyLock {
// 测试转账的main方法
public static void main(String[] args) throws InterruptedException {
    Account src = new Account(10000);
    Account target = new Account(10000);
    CountDownLatch countDownLatch = new CountDownLatch(9999);
    for (int i = 0; i < 9999; i++) {
        new Thread(()->{
            src.transactionToTarget(1,target);
        countDownLatch.countDown();
        }).start();
    }
    countDownLatch.await();
    System.out.println("src="+src.getBanalce() );
    System.out.println("target="+target.getBanalce() );
}
static class Account{ //账户类
    public Account(Integer banalce) {
        this.banalce = banalce;
    }
    private Integer banalce;
    public void transactionToTarget(Integer money,Account target){//转账方法
        Allocator.getInstance().apply(this,target);
        this.banalce -= money;
        target.setBanalce(target.getBanalce()+money);
        Allocator.getInstance().release(this,target);
    }
    public Integer getBanalce() {
        return banalce;
    }
    public void setBanalce(Integer banalce) {
        this.banalce = banalce;
    }
}
static class Allocator { //单例锁类
    private Allocator(){}
    private List<Account> locks = new ArrayList<>();
    public synchronized void apply(Account src,Account tag){
        while (locks.contains(src)||locks.contains(tag)) {
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        locks.add(src);
        locks.add(tag);
    }
    public synchronized void release(Account src,Account tag){
        locks.remove(src);
        locks.remove(tag);
        this.notifyAll();
    }
    public static Allocator getInstance(){
        return AllocatorSingle.install;
    }
    static class AllocatorSingle{
        public static Allocator install = new Allocator();
    }
}
}

点赞@姜戈 补充一下：wait与sleep区别在于：
1. wait会释放所有锁而sleep不会释放锁资源.
2. wait只能在同步方法和同步块中使用，而sleep任何地方都可以.
3. wait无需捕捉异常，而sleep需要.（都抛出InterruptedException ，wait也需要捕获异常）
4. wait()无参数需要唤醒，线程状态WAITING；wait(1000L);到时间自己醒过来或者到时间之前被其他线程唤醒，状态和sleep都是TIME_WAITING
两者相同点：都会让渡CPU执行时间，等待再次调度！

public class Allocator {
    private final List<Account> als=new LinkedList<Account>();
    // 一次性申请所有资源
    public synchronized void apply(Account from, Account to) {
        // 经典写法
        while (als.contains(from) || als.contains(to)) {
            try {
                System.out.println("等待用户 -> "+from.getId()+"_"+to.getId());
                wait();
            } catch (Exception e) {
                //notify + notifyAll 不会来这里
                System.out.println("异常用户 -> "+from.getId()+"_"+to.getId());
                e.printStackTrace();
            }
        }
        als.add(from);
        als.add(to);
    }
    // 归还资源
    public synchronized void free(Account from, Account to) {
        System.out.println("唤醒用户 -> "+from.getId()+"_"+to.getId());
        als.remove(from);
        als.remove(to);
        notifyAll();
    }
}

public class Account {
    // actr 应该为单例
    private final Allocator actr;
    //唯一账号
    private final long id;
    //余额
    private int balance;
    public Account(Allocator actr,long id,int balance){
        this.actr=actr;
        this.id=id;
        this.balance=balance;
    }
    // 转账
    public void transfer(Account target, int amt) {
        // 一次性申请转出账户和转入账户，直到成功
        actr.apply(this, target);
        try {
            //TODO 有了资源管理器，这里的synchronized锁就不需要了吧？！
                    if (this.balance > amt) {
                        this.balance -= amt;
                        target.balance += amt;
                    }
                    //模拟数据库操作时间
                    try {
                        Thread.sleep(new Random().nextInt(2000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
        } finally {
            actr.free(this, target);
        }
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (int) (id ^ (id >>> 32));
        return result;
    }
    /**
     * 用于判断两个用户是否一致
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Account other = (Account) obj;
        if (id != other.id)
            return false;
        return true;
    }
    public long getId() {
        return id;
    }
}
老师，以上代码是我补的，有个疑问，以上有了Allocator管理器（见TODO部分），transfer方法的this跟target都不再需要加synchronized锁了吧？！