java的sleep，wait，join，yield，notify以及interrupt

1.sleep是Thread的静态方法，参数为线程睡眠的时间，线程此时不会让出监视器资源，在睡眠时间内不参与CPU调度，时间到了之后处于就绪状态，参与CPU调度。期间如果调用线程的interrupt方法会抛出异常。
2.wait方法是Object类的方法，会释放线程的监视器资源，因此调用前必须先获取某个监视器资源。期间如果调用线程的interrupt方法会抛出异常。也可以传入一个等待时间参数wait(timeout)，如果一个线程调用共享对象的该方法挂起后，没有在指定的 (timeout)ms 内被其他线程调用该共享变量的notify()或者 notifyAll()方法唤醒，那么该函数还是会因为超时而返回。如果将 timeout置为0则和 wait方法效果一样，因为在 wait 方法内部就是调用了 wait(0)。期间如果调用线程的interrupt方法会抛出异常。
3.notify()方法是Object类的方法，一个线程调用共享对象的 notify()方法后，会唤醒一个在该共享变量上调用 wait()系列方法后被挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。此外，被唤醒的线程不能马上从 wait()方法返回并继续执行，它必须在获取了共享对象的监视器锁后才可以返回。notifyAll()方法则唤醒的是所有在该共享变量上被挂起的方法。
4.join()方法为Thread类的方法，是无参且返回值为void的方法，线程会等待调用join()方法的线程执行完毕后继续执行。期间如果调用主线程的interrupt方法会抛出异常。
5.yield()方法为Thread类的静态方法，当一个线程调用 yield 方法时，实际就是在暗示线程调度器当前线程请求让出自己 CPU 使用，但是线程调度器可以无条件忽略这个暗示。操作系统是为每个线程分配一个时间片来占有CPU 的， 正常情况下当一个线程把分配给自己的时间片使用完后，线程调度器才会进行下一轮的线程调度，而当一个线程调用了Thread 类的静态方法yield()时，是在告诉线程调度器自己占有的时间片中还没有使用完的部分自己不想使用了，这暗示线程调度器现在就可以进行下一轮的线程调度。
当一个线程调用yield()方法时， 当前线程会让出CPU使用权，然后处于就绪状态，线程调度器会从线程就绪队列里面获取一个线程优先级最高的线程，当然也有可能会调度到刚刚让出CPU的那个线程来获取CPU执行权。
6.interrupt()方法
• void interrupt() 方法： 中断线程 例如，当线程A运行时，线程B可以调用线程A的interrupt() 方法来设置线程A的中断标志为 true并立即返回。设置标志仅仅是设置标志，线程A实际并没有被中断，它会继续往下执行。如果线程A因为调用了
wait()系列函数、 join()方法或者 sleep()方法而被阻塞挂起，这时候若线程B调用线程A的interrupt()方法，线程A会在调用这些方法的地方抛出InterruptedException异常返回。
• boolean isinterrupted() 方法： 检测当前线程是否被中断，如果是返回 true,否则返回false。
• boolean interrupted()方法： 检测当前线程是否被中断，如果是返回 true，否则返回false 。与 islnterrupted()不同的是，该方法如果发现当前线程被中断，则会清除中断标志，并且该方法是static方法，可以通过 Thread 类直接调用。另外从下面
的代码可以知道 interrupted()内部是获取当前调用线程的中断标志而不是调用
interrupted()方法的实例对象的中断标志。

public static boolean interrupted() { 
／／清除 中断标志
return currentThread() .isinterrupted(true ); 
}

一个wait和notify测试的小代码：

	@Test
    public void letsTest(){
        int[][] p = {{1,10,4,2},{9,3,8,7},{15,16,17,12}};
        int a = 2;
        int b = 7;
        int c = 0;
        Thread t = new Thread1();
        Thread tt = new Thread2();
        t.start();
        tt.start();
        System.out.println("done");
    }
    private String ss = "123";
    public class Thread1 extends Thread{
        @Override
        public void run() {
            synchronized (ss) {
                System.out.println("1 run 1st");
                try {
                    ss.wait();
                } catch (Exception e) {
                    System.out.println("exception occur.");
                    ss.notify();
                }
                System.out.println("1 return");
            }
        }
    }

    public class Thread2 extends Thread{
        @Override
        public void run() {
            synchronized (ss) {
                System.out.println("2 run 1st");
                try {
                    ss.notify();
                } catch (Exception e) {
                    System.out.println("exception occur.");
                }
                System.out.println("2 continue");
            }
        }
    }

输出结果如下：（notify之后的代码先执行完毕才会进入另外一个线程继续执行）

done
1 run 1st
2 run 1st
2 continue
1 return