1线程的创建方式
1.1直接继承Thread
class MyThread extends Thread {
@Override
public void run() {
super.run();
}
}
1.2实现Runble接口
class MyRunble implements Runnable{
@Override
public void run() {
}
}
1.3实现Callable接口(这种方式严格意义上来说 并不是一种实现方式 本质上是Runnable的实现方式)
class MyCallable extends Callable<String>{
@Override
public String call() throws Exception {
return "返回值";
}
}
1.4对应的调用方式
public static void main(String[] args){
//方式一
MyThread myThread = new MyThread();
myThread.start();
//方式二
new Thread(new MyRunble()).start();
//方式三(FutureTask最终派生自Runnable)
FutureTask<String> futureTask = new FutureTask<String>(new MyCallable());
new Thread(futureTask).start();
futureTask.get();//获取返回值
}
1.4不同创建方式的区别
采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。
Runnable和Callable的区别：
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以，因为run方法本身没有抛出异常，所以自定义的线程类在重写run的时候也无法抛出异常
(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
start()和run()的区别
start()方法用来，开启线程，但是线程开启后并没有立即执行，他需要获取cpu的执行权才可以执行
run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）
2线程的停止方式
2.1stop()
暴力的停止，会造成危险和问题，不可使用，不详细介绍。
interrupt()
目前最优的办法，目的是为了完成run方法的运行。
调用interrupt()方法分为两种情况，当前线程是否调用了sleep，不同的情况，处理方式不一样。
2.2.1未调用
static class MyThread extends Thread {
@Override
public void run() {
super.run();
while (!isInterrupted()){
System.out.println("MyThread run");
}
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//方式一
MyThread myThread = new MyThread();
myThread.start();
Thread.sleep(2);
//发射终止信号
myThread.interrupt();
}
运行截图：
这种方式就是改变isInterrupted的值，从而达到退出循环的目的，当然我们可以根据自己的实际情况来加入判断，从而完成run方法的运行，达到停止线程的目的。
isInterrupted是系统提供的，默认值是false所以我们在判断的时候要加上!。当我们调用interrupt()方法后，isInterrupted会被置为true。
2.2.1调用
static class MyThread extends Thread {
@Override
public void run() {
super.run();
while (!isInterrupted()){
System.out.println("MyThread run");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
我们在之前代码的基础上加了sleep方法，这时我们发现，循环不能被停止了(调用代码不变)。
为什么我们只是让线程睡一觉，就不行了呢？
我们先看下sleep的源码
public static native void sleep(long millis) throws InterruptedException;
通过源码我们发现，sleep方法会抛出一个InterruptedException异常。
当我们调用interrupt()方法后，如果线程调用sleep方法，那么就会抛出InterruptedException异常，而在抛出异常的时候，会清除中断标记。所以当循环进行下一次循环的时候，还是会满足条件，继续执行。
这里我们要注意的一点是，调用interrupt()方法后，调用sleep方法抛出异常的时候会清除中断标记，而wait不会。
要注意的是，如果我们没有调用interrupt()方法，调用sleep()方法的时候，是不会抛出异常的，这点我觉得很重要，因为这点我苦恼了半天，后来自己跑了几遍代码才发现是这么回事。
综上所述，我们得知了调用sleep()方法时会抛出InterruptedException异常，并且会清除中断标记，那么我们就可以在异常捕获阶段进行处理了。
static class MyThread extends Thread {
@Override
public void run() {
super.run();
while (!isInterrupted()){
System.out.println("MyThread run");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
//根据自己的需要 再将isInterrupted置为true
interrupt();
e.printStackTrace();
//根据当前代码逻辑 我们可以直接终止循环
break;
}
}
}
}
2.1守护线程
我们也可以通过setDaemon()方法将线程设为守护线程，这样当被守护的线程执行完后，守护线程也就随之而结束了。
public static void main(String[] args) throws ExecutionException, InterruptedException {
//方式一
MyThread myThread = new MyThread();
myThread.setDaemon(true);
myThread.start();
Thread.sleep(1000);
// //发射终止信号
// myThread.interrupt();
}
上面的代码也就是说myThread守护main线程 main线程结束 不管myThread是否结束 myThread都要结束。
(谁调用的myThread，myThread就守护谁，main线程调用的，myThread就守护main线程)
