java线程的两种启动方式

/**
 * 实现Runnable接口
 * @author dell
 */
public class TicketRunnable implements Runnable{

//实现run方法
@Override
public void run() {
for(int i=0; i<10; i++){
System.out.println(i+"  当前的线程为  "+Thread.currentThread().getName());
}
}

public static void main(String[] args) {

//单个线程执行单个任务
TicketRunnable runnable1 = new TicketRunnable();
TicketRunnable runnable2 = new TicketRunnable();
TicketRunnable runnable3 = new TicketRunnable();
Thread t1 = new Thread(runnable1);
Thread t2 = new Thread(runnable2);
Thread t3 = new Thread(runnable3,"t3");//设置当前线程名称为runnable3
t1.start();
t2.start();
t3.start();

//两个线程执行单个任务
TicketRunnable runnable11 = new TicketRunnable();
Thread t11 = new Thread(runnable11,"t11");
Thread t22 = new Thread(runnable11,"t22");
t11.start();
t22.start();
}

}

/**
 * 继承Thread类
 * @author dell
 */
public class TickedThread extends Thread{

//重新run方法
public void run() {
for(int i=0; i<10; i++){
System.out.println(i+"  当前的线程为  "+Thread.currentThread().getName());
}
}

public static void main(String[] args) {
//单个线程执行单个任务
TickedThread thread1 = new TickedThread();
TickedThread thread2 = new TickedThread();
TickedThread thread3 = new TickedThread();
Thread t1 = new Thread(thread1);
Thread t2 = new Thread(thread2);
Thread t3 = new Thread(thread3,"t3");//设置当前线程名称为runnable3
t1.start();
t2.start();
t3.start();

//两个线程执行单个任务
TickedThread thread11 = new TickedThread();
Thread t11 = new Thread(thread11,"t11");
Thread t22 = new Thread(thread11,"t22");
t11.start();
t22.start();
}
}

线程的状态

创建（NEW）：当程序使用new关键字创建了一个线程后，该线程就处于新建状态。
就绪（可运行RUNNABLE）：线程对象创建后，其他线程（比如main线程）调用了该对象的start方法后，
该状态的线程位于可运行的线程池中，等待被线程调度选中，获取CPU的使用权。此时线程启动，
进入就绪状态。当线程运行之后，从等待或者睡眠中回来后，也会处于就绪状态。
运行（RUNNING）：线程调度程序将处理就绪状态的线程设置为当前线程，此时线程进入运行状态，开始
运行run函数中的代码（即可运行状态的线程获得了CPU的时间片，执行程序代码）。
阻塞（BLOCKED）：线程因为某种原因放弃了CPU的使用权，即让出了CPU时间片，暂时停止运行。
直到线程进入可运行状态，才有机会再次获得CPU时间片，转到运行状态。
阻塞的情况分三种：
(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把
该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
死亡（DEAD）：线程run(),main()方法执行结束，或者调用stop方法，或者因异常退出了run方法后，则该线程结束生命周期。

死亡的线程不可再次复生。

启动线程的两种方式
1，写一个类继承Thread类，重写run方法，用start启动线程。
2，写一个类实现Runnable接口，实现run方法，用start启动线程。

多线程原理：
相当于玩游戏，只有一个游戏机（CPU），可能有很多人（线程）要玩，于是start是排队，等CPU选中你，
你就run,当CPU的运行时间片执行完，这个线程就继续排队，等待下一次的run。
调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程
置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。先调用start
后调用run，这么麻烦，为了不直接调用run？就是为了实现多线程的优点，没这个start不行。

1.start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，
可以直接继续执行下面的代码；通过调用Thread类的start()方法来启动一个线程， 
这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的， 
这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
2.run（）方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码；
程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。

记住：多线程就是分时利用CPU，宏观上让所有线程一起执行 ，也叫并发。

参考文档
https://blog.csdn.net/xuxurui007/article/details/7685076
https://www.cnblogs.com/echo-cheng/p/6814909.html
https://blog.csdn.net/pange1991/article/details/53860651