Thread类的常用方法：
1.start():启动线程并执行相应的run()方法
2.run():子线程要执行的代码放入run()方法中
3.currentThread():获取当前的线程      //静态方法
4.getName():获取子线程的名称
5.setName():设置子线程的名称
6.yield():调用此方法的线程释放当前CPU的执行权
7.join()：在子线程1中调用线程2的join()方法，表示当执行到此方法时，线程1停止执行(阻塞)
8.sleep(long l):显示让当前线程睡眠(毫秒 1s = 1000ms)
9.isAlive():判断当前线程是否存活
10.getPriority():获取优先级,默认是5,最小是1,最大是10
11.setPriority():改变线程的优先级
12.线程通信的方法：

wait():等待

notify():唤醒等待的线程

notifyAll()：唤醒所有等待的线程

1.新建线程

Thread t1 = new Thread();
t1.start();

新建线程，应该调用start()方法启动线程；如果直接调用run()方法，该方法也会执行，但会被当做一个普通的方法，在当前线程中顺序执行；而如果使用start()方法，则会创建一个新的线程执行run()方法。



2.线程中断

public void interrupt();
public boolean isInterrupted();
public static boolean interrupted();

三个方法很相似，线程中断只是通知目标线程有人希望你退出，而并不是使目标线程退出。 

第一个方法是通知目标线程中断，即设置目标线称的中断标志位； 

第二个方法判断当前线程是否被中断，如果被中断（即中断标志位被设置），则返回true，否则返回false； 

第三个方法判断当前线程的中断状态，并清除该线程的中断标志位（也就意味着，如果连续调用两次该方法，并且中间没有再次设置中断标志位，第二次会返回false，因为中断标志位已经被清除）。



public static native void sleep(long millis) throws InterruptedException;

sleep()方法会将当前线程休眠若干ms，如果在休眠期间被调用interrupt()方法，则会抛出InterruptedException异常。如下：

public class TestThread implements Runnable{
    @Override
    public void run() {
        while(true) {
            if(Thread.currentThread().isInterrupted()){ //如果当前线程已经被设置了中断标志位，则返回true
                System.out.println("Interrupted");
                break;
            }

            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Interruted when sleep!");
                Thread.currentThread().interrupt(); //Thread.sleep()方法由于中断而抛出异常，此时，它会清除中断标记；
            }

            Thread.yield();
        }
    }

    public static void main(String[] args){
        Thread t1 = new Thread(new TestThread());
        t1.start();

        t1.interrupt(); //设置目标线程的中断标志位，中断标志位表示当前线程已经被中断了
    }
}



3.等待(wait)和通知(notify)

public final void wait() throws InterruptedException;
public final native void notify();
public final native void notifyAll();

obj.wait()是设置当前线程在该对象上等待，直到有线程调用obj.notify()方法（或notifyAll()方法）。当调用wait()方法后，该线程会进入一个等待队列，等待队列中可能有多个线程，notify()会随机唤醒其中一个线程，而notifyAll()会唤醒所有线程。 

wait()和notify()方法必须在sychronized代码块中，调用这些方法时都需要先获得目标对象的一个监视器，然后调用这些方法时会释放监视器 

与sleep不同的是，sleep()会一直占有所持有的锁，而wait()会释放锁。



4.等待线程(join)和谦让(yield)

public final void join() throws InterruptedException;
public static native void yield();

如果一个线程的执行需要另一个线程的参与（比如当前线程执行需要另一个线程执行完毕才能继续执行），这时候可以调用join()方法。t1.join()方法表示等待线程t1执行完毕之后，当前线程再继续执行。当然也可以给join()设置时间参数。 

注：join()的本质是让调用线程wait()在当前线程对象实例上，其部分源码如下：

while (isAlive()) {
   wait(0);
}

当线程执行完毕后，它会让被等待的线程在退出前调用notifyAll()通知所有等待的线程继续执行。因此不要在Thread对象实例上使用类似wait()或者notify()等方法。 

yield()方法是使当前线程让出CPU，但该线程会再次抢夺CPU。

单核cpu运行多线程时底层实现原理是多个线程间切换，由于cpu的处理速度很快，看上去像多个线程同时运行。那么我们如何实现让线程T1，T2，T3，在T1执行完成后才执行T2，T2执行完成后才执行T3，也就是线程的串行化，通过Thread类的join方法就可以实现。


join方法：将该线程加入当前线程，当前线程等待加入线程执行完成才继续执行。
例子：
public class ThreadJoinTest implements Runnable {



public static void main(String[] args) throws InterruptedException {

Thread thread = new Thread(new ThreadJoinTest());

thread.start();

thread.join();

System.out.println("主线程结束");

}




@Override

public void run() {

System.out.println("子线程开始");

for(int i = 0; i < 5; i++) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(i);

}

System.out.println("子线程结束");

}

}

执行结果：






join(long  millis)方法：将该线程加班当前线程，当前线程等待加入线程millis时间，当达到millis时间后不管加入线程是否完成，当前线程都继续执行，若加入线程在小于millis时间执行完成，则当前线程等待时间等于加入线程的执行时间。
例子：
public class ThreadJoinTest implements Runnable {



public static void main(String[] args) throws InterruptedException {

Thread thread = new Thread(new ThreadJoinTest());

thread.start();

thread.join(2000);

System.out.println("主线程结束");

}




@Override

public void run() {

System.out.println("子线程开始");

for(int i = 0; i < 5; i++) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(i);

}

System.out.println("子线程结束");

}

}
执行结果：