前言：这篇文章包括了线程
01 线程的实现方式
02 正确启动线程的方式
03 如何停止线程
04 如何中断线程
05 线程的生命周期
06 thread、notify、join、yield的方法说明
07 线程的异常处理
08 死锁的解决方案

线程的实现方式（有三种）

（1）继承Thread类，并重写run()方法。

public class TestMain {
    public static void main(String[] args) {
        //1.继承Thread类，重写run方法。
        Thread thread = new MyThread1();
        thread.start();
    }
}

（2）实现Runnable接口，并实现其run()方法。

public class TestMain {
    public static void main(String[] args) {
        //2.实现runnable接口，并实现该接口的run()方法
        MyThread2 thread2 = new MyThread2();
        Thread t = new Thread(thread2);
        t.start();
    }
}

（3）实现Callable接口，并实现其call()方法。

public class TestMain {
    public static void main(String[] args) {
        //3.实现Callable接口，重写call方法。
        // 启动线程
        try {
            ExecutorService threadPool = Executors.newSingleThreadExecutor();
            Future<String> future = threadPool.submit(new MyThread3());
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

正确启动线程的方式

为什么会用start而不用run：调用start的时候其实调用了run方法，而调用start的时候则创建了新的线程新的线程则在run里面去跑，run相当于类中的普通方法。这样说吧你可以理解为start的优先级比run的高。

public class test {
    public static void main(String[] args) {
        Runnable runnable = ()->{
            System.out.println(Thread.currentThread().getName());
        };

        Thread thread = new Thread(runnable);
        // 设置线程名称
        thread.setName("thread_kaven");
        thread.start();
    }
}

如何停止线程

迫不得已不能使用stop()方法（强制停止线程），因为该方法不安全而且会出现数据混乱问题。这是在jdk1.2之后做出的改变

使用interrupt方法来终端线程可分为两种情况：
（1）线程处于阻塞状态，如使用了sleep方法。
（2）使用while（！isInterrupted（））{……}来判断线程是否被中断。
在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出

第一种情况

public class ThreadInterrupt extends Thread {  
    public void run()  {  
        try {  
            sleep(50000);  // 延迟50秒  
        }  
        catch (InterruptedException e) {  
            System.out.println(e.getMessage());  
        }  
    }  
    public static void main(String[] args) throws Exception  {  
        Thread thread = new ThreadInterrupt();  
        thread.start();  
        System.out.println("在50秒之内按任意键中断线程!");  
        System.in.read();  
        thread.interrupt();  
        thread.join();  
        System.out.println("线程已经退出!");  
    }  
}
/**一下是运行结果
在50秒之内按任意键中断线程!
sleep interrupted
线程已经退出*/

第二种情况

public class ThreadInterrupt extends Thread {  

      public void run() {  
          while (!isInterrupted()) {
              //do something
          }
      }  

      public static void main(String[] args) throws Exception  {  
          Thread thread = new ThreadInterrupt();  
          thread.start();  
          thread.interrupt();  
          thread.join();  
          System.out.println("线程已经退出!"); 
      }  
  }

停止线程的判断方法:
Thread.java类中提供了；两种方法进行判断，分别是：interrupted()和isInterrupted()方法。
Interrupted():测试当前线程是否已经中断。执行后具有清除中断状态的功能。
isInterrupted()：测试线程都否已经中断。没有清除中断状态的功能。

如何中断线程

线程的中断机制：
1.如果线程堵塞在object.wait、Thread.join和Thread.sleep，将会清除线程的中断状态，并抛出InterruptedException;
2.如果线程堵塞在java.nio.channels.InterruptibleChannel的IO上，Channel将会被关闭，线程被置为中断状态，并抛出java.nio.channels.ClosedByInterruptException；
3.如果线程堵塞在java.nio.channels.Selector上，线程被置为中断状态，select方法会马上返回，类似调用wakeup的效果；
如果不是以上三种情况，thread.interrupt()方法仅仅是设置线程的中断状态为true。中断代码就不贴了和停止差不多。

线程的生命周期

线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。

新建：就是刚使用new方法，new出来的线程；

就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;

运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;

阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态;

销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源;

thread、notify、join、yield的方法说明

notify:说这个方法顺便说一下wait。wait方法是Object的方法，任何一个对象就可以调用，并且它必须在synchronized修饰的代码块中调用，否则会抛出异常java.lang.IllegalMonitorStateException
它的作用是让当前拥有对象锁的线程阻塞，暂停执行，加入到对象锁的等待队列中，直到其它的线程调用了这个锁对象的notify()或notifyAll()方法来唤醒它。唤醒之后，这个线程就会从之前状态恢复执行。

该方法是实例方法，执行thread.join()不传参的情况下主线程会等待直到thread线程执行完毕后才会继续执行,否则就是暂停传入时间后继续执行.果你想打断这种暂停, 那么你可以在thread中调用notify(),notifyAll()方法来打断（其实不推荐使用这几种方法）.
join:当前线程暂停执行
join(long millis): 当前线程暂停执行,直到millis毫秒之后继续执行
join(long millis, int nanos): 当前线程执行暂停, 直到millis+namos后继续

yield：可以使当前线程从执行状态（运行状态）变为可执行态（就绪状态），会让当前线程停下来

thread：这是一个线程类，里面包含了许多的方法包括上述介绍的三种等！！！

线程的异常处理

在java多线程程序中，所有线程都不允许抛出未捕获的checked exception，也就是说各个线程需要自己把自己的checked exception处理掉。这一点是通过java.lang.Runnable.run()方法声明(因为此方法声明上没有throw exception部分)进行了约束。但是线程依然有可能抛出unchecked exception，当此类异常跑抛出时，线程就会终结，而对于主线程和其他线程完全不受影响，且完全感知不到某个线程抛出的异常(也是说完全无法catch到这个异常)。在Java中，线程方法的异常（无论是checked还是unchecked exception），都应该在线程代码边界之内（run方法内）进行try catch并处理掉.

但如果线程确实没有自己try catch某个unchecked exception，而我们又想在线程代码边界之外（run方法之外）来捕获和处理这个异常的话，java为我们提供了一种线程内发生异常时能够在线程代码边界之外处理异常的回调机制，即Thread对象提供的setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)方法。

通过该方法给某个thread设置一个UncaughtExceptionHandler，可以确保在该线程出现异常时能通过回调UncaughtExceptionHandler接口的public void uncaughtException(Thread t, Throwable e) 方法来处理异常，这样的好处或者说目的是可以在线程代码边界之外（Thread的run()方法之外），有一个地方能处理未捕获异常。但是要特别明确的是：虽然是在回调方法中处理异常，但这个回调方法在执行时依然还在抛出异常的这个线程中！另外还要特别说明一点：如果线程是通过线程池创建，线程异常发生时UncaughtExceptionHandler接口不一定会立即回调。

通过UncaughtExceptionHandler处理异常

/**
 * 任务
 */
class Task implements Runnable{

    @Override
    public void run(){
        System.out.println(2/67);
        System.out.println(2/0);
    }
}

//通过UncaughtExceptionHandler实现
class ExcedptionHandler implements Thread.UncaughtExceptionHandler{
    @Override
    public void uncaughtException(Thread t,Throwable e){
        System.out.println("运行时异常;"+e.getMessage());
    }
}

public class Main {

    public static void main(String[] args) {
       Thread t=new Thread(new Task());
       t.setUncaughtExceptionHandler(new ExcedptionHandler());
       t.start();
    }
}

结果0
运行时异常;/ by zero

死锁的解决方案

两个或多个线程互相持有对方需要的锁而导致这些线程全部处于永久阻塞状态产生死锁，个人认为产生死锁的原因是竞争资源

解决方案：
1.资源排序
2.加锁时限
如果一个线程没有在指定的时间期限内获取到锁，则结束当前线程并释放掉已获得的锁。终止线程的方法：stop()会释放掉锁但易导致数据不一致。suspend()终止线程但不会释放掉锁。
3.死锁检测
个人水平有限只能写到这里，进程死锁一般不会遇到！！！