Java基础之创建线程本质方法, 线程的状态, 如何终止线程

1. 创建线程本质方法

1.1 两种方法

• 继承Thread类，重写run方法。用start()方法启动线程
• 实现Runnable接口，实现run方法,new Thread(Runnable r).start()启动线程.

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
run()是线程的方法本体.
Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法

1.2 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

1.3 Thread的run()方法和start()方法的区别

java的线程是通过java.lang.Thread类来实现的。JVM启动时会有一个由主方法所定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

1.4 多线程(并发)原理

相当于随机演讲,只有一个讲台(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，宏观上让所有线程在同一时间段内执行 ，即并发.

2. 线程的状态及如何退出线程

2.1 java中线程的状态

在Java当中，线程通常都有5种状态，新建状态、就绪状态、运行状态、阻塞状态和死亡状态。

1. 第一是新建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
2. 第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。
3. 第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
4. 第四是阻塞状态。阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
   (1)等待 – 通过调用线程的wait() 方法，让线程等待某工作的完成。
   (2)超时等待 – 通过调用线程的sleep() 或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
   (3)同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
5. 第五是死亡状态: 线程执行完了或者因异常退出了run()方法，该线程结束生命周期.

2.2 Java中wait和sleep的区别

2.2.1 线程等待wait

调用该方法的线程进入Waiting状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用wait()方法后，会释放对象的锁。因此，wait方法一般用在同步方法或同步代码块中。

2.2.2 线程睡眠sleep

sleep导致当前线程休眠，与wait方法不同的是sleep不会释放当前占有的锁，sleep(long)会导致线程进入Timed-Waiting状态,而wait()方法会导致当前线程进入Waiting状态.

2.2.3 区别

最大的不同是,等待wait时会释放锁,而sleep一直持有锁.wait通常被用于线程间交互,sleep通常被用于暂停执行.

2.3 如何终止线程

如上提到了创建线程的本质方法, 及线程创建后的5种状态, 那么如何终止一个线程呢?
Java中的Thread类虽然有stop()方法可以中断一个线程,但是由于可能会导致资源无法正常释放等问题, 已经被废弃, 所以需要另寻他法.

2.3.1 第一种:结合实际开发业务, 打标志

中断线程最好的方式就是结合线程的业务逻辑, 通过设置标记位, 让线程任务提前结束.

1.   //volatile修饰符用来保证其它线程读取的总是该变量的最新的值
2.    public volatile boolean exit = false; 
3.    @Override
4.    public void run() {
5.               while(!exit){
6.                ...//业务逻辑
7.        }
8.    }
 
 // 如下开启此线程, 并给exit赋值操作, 当!exit=true, 退出run()方法, 线程终止.

2.3.2 使用Thread类的interrupt()方法

• 用 interrupt() 方法仅仅是在当前线程中打一个停止的标记, 线程并不会立即终止线程. 而是通知目标线程, 有人希望你终止.
• 至于线程收到通知后会如何处理, 则完全由线程自行决定.

1.public static void main(String[] args) throws InterruptedException {
	      //1. 创建线程
3.        Thread thread = new Thread(new Runnable() {
4.            @Override
5.            public void run() {
6.                long startTime = System.currentTimeMillis();
7.                for (int i=0;i<1000000;i++){
8.                    System.out.println("任务正在执行中："+i);
9.                }
10.                System.out.println("任务执行完毕，耗时："+(System.currentTimeMillis() - startTime));
11.            }
12.        });
13.        //2.启动线程
14.        thread.start();
15.        //让主线程, 也就是main方法睡眠2000毫秒，然后中断该子线程
16.        Thread.sleep(2000);
17.        
18. 		//3.给线程打标记终止线程
19.        thread.interrupt();
20.    }

但是通过运行结果, 发现子线程并未被终止.

2.3.3 使用isInterrupted()终止线程

如果想终止任务, 还需要结合使用Thread.isInterrupted()方法：

1.public static void main(String[] args) throws InterruptedException {
	      //1. 创建线程
3.        Thread thread = new Thread(new Runnable() {
4.            @Override
5.            public void run() {
6.                long startTime = System.currentTimeMillis();
7.                for (int i=0;i<1000000;i++){
8.                    //判断当前线程的状态是否已经标记为终止, 此Thread指的是子线程.
9.                    if (Thread.interrupted()){
10.                        //如果线程已经标记为终止则跳出循环（其实就是结束任务了）
11.                       break;
12.                    }
13.                    System.out.println("任务正在执行中："+i);
14.                }
15.                System.out.println("任务执行完毕，耗时："+(System.currentTimeMillis() - startTime));
16.            }
17.        });
18. 
19.        //2.启动子线程
20.        thread.start();
21.        //让主线程也就是main方法睡眠2000毫秒，然后中断子该线程
22.        Thread.sleep(2000);
24. 		//3.给子线程打标记终止线程
25.        thread.interrupt();
26.    }

在上面这段代码中, 我们增加了 Thread.isInterrupted() 来判断当前线程是否被中断了, 如果是, 则退出 for 循环, 结束线程.

线程被成功终止了.

备注: 如果线程处于sleep()或者wait()状态, 如何终止此线程

使用try…catch…, 在catch中跳出循环或者终止线程.

1.public static void main(String[] args) throws InterruptedException {
	      //1. 创建线程
3.        Thread thread = new Thread(new Runnable() {
4.            @Override
5.            public void run() {
6.                long startTime = System.currentTimeMillis();
7.                for (int i=0;i<1000000;i++){
8.                    //判断当前线程的状态是否已经标记为终止, 此Thread指的是子线程.
9.                    if (Thread.interrupted()){
10.                        //如果线程已经标记为终止则跳出循环（其实就是结束任务了）
11.                       break;
12.                    }
11.                    try {
12.                        //如果此子线程正在睡眠状态，被终止时被抛出InterruptedException异常，并且会清除interrupt终止位
13.                        Thread.sleep(10);
14.                        System.out.println("任务正在执行中："+i);
15.                    } catch (InterruptedException e) {
16.                        e.printStackTrace();
17.                        //当线程被终止时会遇到异常，在异常中终止线程
18.                        break;
19.                    }
14.                }
15.                System.out.println("任务执行完毕，耗时："+(System.currentTimeMillis() - startTime));
16.            }
17.        });
18. 
19.        //2.启动子线程
20.        thread.start();
21.        //让主线程也就是main方法睡眠2000毫秒，然后中断子该线程
22.        Thread.sleep(2000);
24. 		//3.给子线程打标记终止线程
25.        thread.interrupt();
26.    }

结果如下