定义一个多线程

继承Thread类创建线程：

public class Thread extends Object implements Runnable 

Thread类本身就实现了一个Runnable接口，在Thread类的定义中有run()方法。
通过继承Thread类创建线程的步骤如下：

1. 从Thread类派生子类，并重写其中的run()方法定义线程体
2. 创建该子类的对象创建线程

public class ThreadTest2{
    public static void main(String args[]){
    Hello t1 =new Hello();
    Hello t2 =new Hello();
    t1.start();
    t2.start();
    
}

}
class Hello extends Thread{
    int i;
    public void run(){
         while(true){
            System.out.println("Hello"+i++);
            if(i==5)  break;
            }
}

}

实现Runnable接口

public interface Runnable{
     void run();
}

创建线程的步骤如下：

1. 定义一个类实现Runnable接口，即在该类中提供run()方法实现
2. 把Runnable的一个实例作为参数传给Thread类的一个构造方法，该实例对象提供线程体run().

public class ThreadTest{
    public static void main(String args[]){
        Thread t1= new Thread(new Hello());
        Thread t2= new Thread(new Hello());
        t1.start();
        t2.start();
    }
}

class Hello implements Runnable{
    int i;
    public void run(){
    while (true){
       System.out.println("Hello"+i++);
       if(i==5)  break;
    }
    }

}

采用继承Thread类方法的优点

这种方法中代码简单，并可以在run()方法中直接调用线程的其他方法

实现Runnable接口的优势

1. 符合面向对象设计的思想
2. 便于继承其他类

线程的基本控制

1.sleep()

sleep()方法能够把CPU让给优先级比其低的线程。

//sleep()方法发格式：
static void sleep(int millsecond);//休眠的时间以毫秒为单位
static void sleep(int millsecond,int nanosecond);//休眠时间是指定的毫秒数和纳秒数之和

2.yield()

调用该方法后，可以使具有与当前线程相同的优先级的线程有与运行的机会。

3.join()

t.join()方法使当前的线程等待直到线程t结束为止，该线程恢复安东Runnable状态。

1. join()：如果当前线程发出调用t.join()，则当前线程将等待线程t结束再继续执行
2. join(long millis):如果当前线程发出调用t.join()，则当前线程将等待线程t结束或最多等待mills毫秒后，在继续执行
3. join(long millis,int nanos):如果当前线程发出调用t.join()，则当前线程将等待线程t结束或最多等待mills毫秒+nanos纳秒后，在继续执行

4.interrupt()

如果一个线程t在调用sleep(),join(),wait()等方法被阻塞时，则t.interrupt()方法将中断t的阻塞状态，并且t将接收到InterruptExcepton异常

5.currentThread()

Thread类的静态方法currentThread()返回当前线程，具体是返回当前线程的引用

6.isAlive()

isAlive（）测试线程是否存货。该方法返回true表示线程已经启动，但是没有运行结束

7.stop()

当该线程结束后就不能再运行了。

8.suspend()与resume()

在一个线程中调用t.suspend()，将使另一个线程t暂时停止。想恢复线程，就必须用其他线程调用t.resume(）