四、sleep（）和wait（）和suspend（）的区别
　　区别一：
　　sleep是Thread类的方法，是线程用来控制自身流程的，比如有一个要报时的线程，每一秒中打印出一个时间，那么我需要在print方法前面加上一个sleep让自己每隔一秒执行一次。像个闹钟一样。  sleep() 指示当前线程暂停执行指定时间，把执行机会让给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
　　wait是Object类的方法，用来线程间的通信，这个方法会使当前拥有该对象锁的线程等待，直到其他线程调用notify方法时再醒来，不过你也可以给它指定一个时间，自动醒来。这个方法主要是用在不同线程之间的调度。 对象调用wait()方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
　　区别二 ：
　　调用wait方法会释放当前线程的锁，其实线程间的通信是靠对象来管理的，所有操作一个对象的线程是这个对象通过自己的wait方法来管理的。好像这个对象是电视机，三个人是三个线程，那么电视机的遥控器是这个锁，假如现在A拿着遥控器，电视机调用wait方法，那么A交出自己的遥控器，由jVM虚拟机调度，遥控器该交给谁。
　　调用sleep方法不会释放锁，因为sleep（）是一个线程用于管理自己的方法，不涉及线程通信。还是上面的例子，如果A拿遥控器的期间，他可以用自己的sleep每隔十分钟调一次台，而在他调台休息的十分钟期间，遥控器还在他的手上，其他人无法获得遥控器。
　　suspend() 方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，会造成死锁
　　在以下情况下，持有锁的线程会释放锁：
　　1. 执行完同步代码块。
　　2. 在执行同步代码块的过程中，遇到异常而导致线程终止。
　　3. 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进行对象的等待池。
　　在以下情况下，线程虽然停止执行，但是线程不会释放锁：
　　1. 在执行同步代码块的过程中，执行了Thread.sleep()方法，当前线程放弃CPU，开始睡眠，在睡眠中不会释放锁。
　　2. 在执行同步代码块的过程中，执行了Thread.yield()方法，当前线程放弃CPU，但不会释放锁。
　　3. 在执行同步代码块的过程中，其他线程执行了当前对象的suspend()方法，当前线程被暂停，但不会释放锁。
　　五、在静态方法上使用同步
　　JAVA只识别两种类型的锁：对象锁和类锁。
　　同步静态方法时会获取该类的"Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的锁，对整个类加锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。测试代码如下：
　　public class Common implements Runnable {
　　public synchronized static void method1() throws InterruptedException {
　　Thread.sleep(1000);
　　System.out.println("Method 1 called");
　　Thread.sleep(1000);
　　System.out.println("Method 1 done");
　　}
　　public synchronized static void method2() throws InterruptedException {
　　Thread.sleep(1000);
　　System.err.println("Method 2 called");
　　Thread.sleep(1000);
　　System.err.println("Method 2 done");
　　}
　　public void run() {
　　System.out.println("Running " + Thread.currentThread().getName());
　　try {
　　if (Thread.currentThread().getName().equals("Thread-1")) {
　　method1();
　　} else {
　　method2();
　　// Thread.currentThread().notify();
　　}
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　public static void main(String[] args) throws InterruptedException {
　　//以下代码创建了不同的对象上的不同线程，用来测试对于同一个类，会不会有锁
　　Common c1 = new Common();
　　Common c2 = new Common();
　　Thread t1 = new Thread(c1， "Thread-1");
　　Thread t2 = new Thread(c2， "Thread-2");
　　t1.start();
　　t2.start();
　　}
　　}
　　执行结果如下：
　　Running Thread-2
　　Running Thread-1
　　Method 2 called
　　Method 2 done
　　Method 1 called
　　Method 1 done
　　六、在一个对象上两个线程可以在同一时间分别调用两个不同的同步实例方法吗？
　　不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。测试代码如下：
　　public class Common implements Runnable {
　　public synchronized void method1() throws InterruptedException {
　　Thread.sleep(1000);
　　System.out.println("Method 1 called");
　　Thread.sleep(1000);
　　System.out.println("Method 1 done");
　　}
　　public synchronized void method2() throws InterruptedException {
　　Thread.sleep(1000);
　　System.err.println("Method 2 called");
　　Thread.sleep(1000);
　　System.err.println("Method 2 done");
　　}
　　public void run() {
　　System.out.println("Running " + Thread.currentThread().getName());
　　try {
　　if (Thread.currentThread().getName().equals("Thread-1")) {
　　method1();
　　} else {
　　method2();
　　// Thread.currentThread().notify();
　　}
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　public static void main(String[] args) throws InterruptedException {
　　Common c = new Common();
　　Thread t1 = new Thread(c， "Thread-1");
　　Thread t2 = new Thread(c， "Thread-2");
　　t1.start();
　　t2.start();
　　//        以下代码作为对比，创建不同的对象，则不会受对象锁的干扰了
　　//        Common c1 = new Common();
　　//        Common c2 = new Common();
　　//        c1.start();
　　//        c2.start();
　　}
　　}
　　执行结果如下：
　　Running Thread-1
　　Running Thread-2
　　Method 1 called
　　Method 1 done
　　Method 2 called
　　Method 2 done