Thread相关方法介绍

1、Object.wait(),Object.notify()
作用：当在一个线程内调用object.wait方法后，这个线程会释放掉当前持有的对象锁，直到调用object.notify方法唤醒。
注意事项：需要在synchronized同步块中执行。
例子：

final Object o = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(o) {
                    Log.d(TAG,"T1获取synObj的对象监视器，开始执行同步块");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                        Log.d(TAG,"T1在 wait()时挂起了");
                        o.wait();
                        Log.d(TAG,"T1被T2唤醒后并重新获得synObj的对象监视器，继续执行");
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.d(TAG,"T1获取synObj的对象监视器，结束同步块");
                }
            };
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"T2启动，但是因为T1占用了synObj的对象监视器，则等待T1执行synObj.wait来释放它");
                synchronized(o) {
                    try {
                        Log.d(TAG,"在T1执行synObj.wait后，T2获取synObj的对象监视器，进入同步块");
                        o.notify();
                        Log.d(TAG,"T2执行synObj.notify()，T1被唤醒，但T2还在同步块中，没有释放synObj的对象监视器，T1等待synObj的对象监视器");
                        TimeUnit.SECONDS.sleep(1);
                        Log.d(TAG,"T2结束同步块，释放synObj的对象监视器，T1获取到synObj的对象监视器，并执行wait后面的操作");
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        });

        t1.start();
        t2.start();

结果：
T1获取synObj的对象监视器，开始执行同步块
T2启动，但是因为T1占用了synObj的对象监视器，则等待T1执行synObj.wait来释放它
T1在 wait()时挂起了
在T1执行synObj.wait后，T2获取synObj的对象监视器，进入同步块
T2执行synObj.notify()，T1被唤醒，但T2还在同步块中，没有释放synObj的对象监视器，T1等待synObj的对象监视器
T2结束同步块，释放synObj的对象监视器，T1获取到synObj的对象监视器，并执行wait后面的操作
T1被T2唤醒后并重新获得synObj的对象监视器，继续执行
T1获取synObj的对象监视器，结束同步块

与Thread.sleep的区别：
1、Thread.sleep无需再同步语句中执行
2、Thread.sleep不会释放锁

2、Thread.yield()
作用：当前正在执行的线程把运行机会交给线程池中拥有相同优先级的线程。调用yield的时候锁并没有被释放。

3、Thread.join()
作用：此方法不是静态方法。当某个线程调用此方法后，其他线程要等到这个线程执行完后才能继续执行。
Thread.join(long millis)，等待millis 毫秒终止线程，假如这段时间内该线程还没执行完，那么结束等待，2个线程并发执行
例子：

JoinThread joinThread = new JoinThread();
        joinThread.start();
        try {
            joinThread.join(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(1000);
                Log.d(TAG,"main"+i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
class JoinThread extends Thread{
        @Override
        public void run() {
            for (int i=0;i<10;i++){
                Log.d(TAG,"JoinThread"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果：
JoinThread0
JoinThread1
JoinThread2
main0
JoinThread3
main1
JoinThread4
main2
JoinThread5
main3
JoinThread6
main4
JoinThread7
main5
JoinThread8
main6
JoinThread9
main7
main8
main9