今天我们进一步学习了多线程，请按照自己的理解回答下面问题：
1.多线程的实现有几种方式？实现步骤分别是怎样的？
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
5.线程有几种状态？他们之间是如何转化的？

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread，实现runtime接口，但实际上都是实现了runtime接口，而继承Thread类还有单继承局限
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口的优势： 1. 适合多个相同的程序代码的线程去共享同一个资源。 2. 可以避免java中的单继承的局限性。 3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。 4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样 的，而且其他的变量的值也和预期的是一样的，就是线程安全的。线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全
4.sleep()方法和wait()方法的区别？
Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。
5.线程有几种状态？他们之间是如何转化的？
NEW(新建) 线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行) 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。
Blocked(锁阻 塞) 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限 等待) 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时 等待) 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated(被 终止) 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

1.多线程的实现有几种方式？实现步骤分别是怎样的？

l 第一种方式是将类声明为 Thread 的子类。

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2. 创建Thread子类的实例，即创建了线程对象。

3. 调用线程对象的start()方法来启动该线程。

l 第二种方式是声明一个类实现Runnable 接口。

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。

3. 调用线程对象的start()方法来启动线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别:
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

     优势:

1. 适合多个相同的程序代码的线程去共享同一个资源。

2. 可以避免java中的单继承的局限性。

3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。

4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写
操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，
否则的话就可能影响线程安全.

Java中提供了同步机制(synchronized)来解决

1. 同步代码块。
2. 同步方法。
3. 锁机制。

4.sleep()方法和wait()方法的区别？
sleep() 必须是有参,wait()可以是无参
sleep()在设定时间内不释放锁
wait()会马上释放锁

5.线程有几种状态？他们之间是如何转化的？
NEW(新建)                 线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)       线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)          当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)       一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TimedWaiting(计时等待)    同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep .Object.wait。
Teminated(被终止)         因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

1.两种  一种通过创建Thread的子类对象   另一种通过创建 Runnable接口的实现类 以此类对象为参数创建 Thread对象
两者都要重写run方法和调用start方法
2.区别在于使用  后者优点 更多  1. 同方法资源共享 2. 避免了单继承的局限性 3. 健壮性较强,实现解耦操作 4.线程池能放入
3.多线程共用一个资源出现争抢  目前3种   1.synchronized(同步锁) 同步代码块  2.同步方法 public synchronized void XXX(){}  3.lock锁    创建reentrant对象 调用  lock和unlock方法
4.如果开始执行当前线程调用sleep方法当前线程进入休眠且不会切换到另外一个线程
用wait停止当前线程切换到另一个线程,直到获得相同对象同步锁notify方法,并且重新获得获得锁对象才会执行.
5.六种  new runnable blocked waiting timedwaiting terminate
新建new  获得锁对象时 进入runnable  没获得blocked状态 waiting无限等待直到获得notify和锁对象  timedwaiting时间结束或获得notify并获得锁对象 run结束或异常终止进入terminated

多线程的实现有几种方式？实现步骤分别是怎样的？
1:多线程的实现有两种方式
第一种方式是将类声明为Thread的子类:
       1.定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体.
       2: 创建Thread子类的实例,即创建了线程对象.
       3: 调用线程对象的start()方法来启动该线程.
第二种方式是声明一个类的实现Runnable接口:
     1:定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同一是该线程的线程执行体.
     2: 创建Runnable实现类的实例,并以此实例为Thread的target来创建Thread对象,Thread对象才是真正的线程对象.
     3: 调用线程对象的start()方法来启动线程.
.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别在于:  如果继承Thread,则不适合资源共享.但是如果实现了Runnable接口的话,则很容易实现资源共享.
    1: 适合多个相同的程序代码的线程去共享同一个资源;
    2: 可以避免java中的单继承的局限性;
    3: 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和数据独立;
    4: 线程池只能放入实现Runnable或callable类线程,不能直接放入继承Thread的类.
线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
      线程安全问题都是由全局变量及静态变量引起的.若每个线程中对全局变量,静态变量只有读的操作,而无写的操作,一般来说,这个全局变量是线程安全的,若有多个线程同时执行写操作,一般都需要考虑线程同步,否则的话就可能影响线程安全.
    有三种解决线程安全的方式
    1: 同步代码块;
    2: 同步方法;
    3: 锁机制;
sleep()方法和wait()方法的区别?
Sleep();与锁无关,线程睡眠到期自动苏醒,并返回到Runnable(可运行)状态;
wait(): 则需要notify唤醒才能苏醒,如果不唤醒会一直睡眠;
  线程有几种状态？他们之间是如何转化的？
线程有六种状态,
1:New(新建)线程刚被创建,但是并未启动;
2: Runnable(可运行)
     线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决于操作系统处理器.
3. Blocked(锁阻塞)
    当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blcked状态;当该线程持有锁时,该线程将会变成Runnable状态.
4.  Waiting(无限等待)
一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态.进入这个状态后是不能自动唤醒的,必须等待另一个线程调用notify或者notifyAll方法才能够唤醒.
5. Timed Waiting(计时等待)
     同Waiting状态,有几个方法有超时参数,调用他们将进图Timeed Waiting状态.这一状态将一直保持到超时期满或者受到唤醒通知.带有超时参数的常用方法有Thread,Object.wait.
6. Teminated(被终止)
     因为run方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡.
     

今天我们进一步学习了多线程，请按照自己的理解回答下面问题：
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种实现方式:
(1)创建Thread类的子类.
(2)实现Runnable接口.
实现步骤:
(1)Thread子类: 重写 run() 方法,方法体是线程需要执行的任务,创建实例类,在该实例类中创建Thread子类对象,后通过开启子线程任务(对象名.start();).
(2)实现Runnable接口,重写 run() 方法,方法体也是线程需要执行的任务,创建实例类,在该实例类中创建Runnable实现类对象,再创建一个Thread线程类对象,将Runnable实现类对象作为Thread的参数放入线程类中,后调用Thread.start()方法.
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
(1)继承Thread类: java中,类与类智能单继承,也就不适合资源共享,(一个任务多人做),需要创建多个子类对象,分别完成这个任务.
   实现Runnable接口: 能资源共享,一个任务多人完成,把任务交给Thread线程类去完成这个任务.
(2)实现Runnable接口的优势:
        -1.适合相同代码的线程去共享一个资源
        -2.避免java的单继承性
        -3.增加程序健壮性,实现解耦操作,代码可以被多个线程共享,代码与线程独立.
        -4.线程池只能能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
(1)sleep()方法是一个静态方法,通过Thread 直接调用的,需要参数(毫秒值),表示线程暂停执行;
(2)wait()方法是Object父类的方法,需要创建对象进行调用,可以不写参数(需要被唤醒,否则处于一直等待中),表示当前线程等待.
5.线程有几种状态？他们之间是如何转化的？
(1)线程有六种状态:
        -1.new(新建): 线程被创建但为启动,调用start方法;
        -2.Runnable(可运行): 线程在java虚拟机运行的状态,可能在运行自己的代码
        // -3.Blocked(锁阻塞): 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状
        态；当该线程持有锁时，该线程将变成Runnable状态。
        -4.Waiting(无限等待): 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个
        状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
        -5.TimedWaiting(计时等待): 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、
        Obj
        -6.Teminated(被终止): 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

1.多线程的实现有几种方式？实现步骤分别是怎样的？ （1）继承Thread类，重写父类run()方法 （2）实现Runnable接口,实现里面的run()方法，在创建Thread对象的时候，将Runnable接口的子实现类作为参数传递给Thread构造函数; 2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？ （1）继承Thread类是产生一个新的线程类，该类中的重写了run方法，Runnable接口主要是将run方法的实现传递给Thread对象，使其执行传递进去的run方法 （2）Runnable接口的优势         1）多个线程线程可以共享一个Runnable实现类，实现资源的共享         2）避免了单继承的局限性         3）耦合性更低，将run方法和Thread线程对象分离         4）在使用线程池的时候，只有实现Runnable接口的或Callable类的线程才能放入，Thread的子类不能放入 3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？ （1）在多个线程对一个共享资源进行读写操作的时候，会产生线程安全 （2）通过线程同步的方式来解决线程安全，也就是保证一个线程的读写操作的原子性，实现线程同步的方式有          1）通过同步代码块实现线程同步，将线程对共享资源的读写操作写在同步代码块中；          2）通过同步方法实现线程同步，将线程的读写操作定义在同步方法中；          3）通过Lock锁实现线程同步，Lock是一个接口，一般使用其实现类ReentrantLock，调用lock()和unclock()方法来实现加锁和解锁，功能比同步代码块和同步方法更多，更能体现面向对象。 4.sleep()方法和wait()方法的区别？ （1）sleep方法需要设置睡眠时间，只能时间到后唤醒，wait可以设置，也可以不设置，使用notify唤醒，或则设置的时间到后唤醒 （2）sleep执行后，进行等待状态不会释放锁，所以此时如果有使用线程同步，其他的线程也不能执行被同步的代码 5.线程有几种状态？他们之间是如何转化的？ （1）有六种状态，分别是：新建态、可运行态、锁阻塞、无线等待、计时等待状态、中值状态 （2）六种状态之间的转换方式        1）新建态：创建后，调用start()方法后可进入可运行态        2）可运行态：没有获取锁对象会进入锁阻塞，获取锁对象后执行wait或sleep方法，会进入无线等待态或计时等待态        3）锁阻态：获取锁对象后会进入可运行态        4）无限等待态：被notify唤醒后，获取锁对象，就进入可运行态，没有获取锁对象，进入锁阻塞        5）计时等待态：计时时间到，获取锁对象则进入可运行态，没有获取锁对象，进入所阻塞        6）终止态：程序运行结束或则异常退出。

1.        多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现方式有三种。一种是继承Thread类，还有两种是通过实现接口：Runnable或Callable类接口。
继承Thread类：创建一个Thread对象，在该对象内重写run()方法，然后用该对象调用start()启动线程。
实现Runnable接口类：先定义Runnable接口的实现类，然后重写该接口的run（）方法，并以此实例作为Thread的target来创建Thread对象,最后调用线程对象的start（）方法来启动线程。
2.        继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：两者的区别就是target的区别。
（1）①继承Thread之后,因为是由一个线程类分别构造了多个个对象,所以每个对象各自有各自的数据,对象之间是数据不共享的，自然无法共享变量了。
②而采用实现Runnable接口类的话，多个线程对该资源只保存一份，而不是每个线程内都各自保存一份。
（2）①适合多个相同的程序代码的线程去共享同一个资源。
②可以避免java中的单继承的局限性。
③增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
④线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。
3.        线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
答：（1）如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果多个线程中对资源都有写的操作，就容易出现线程安全问题。
我们都知道java的内存模型中有主内存和线程的工作内存之分，主内存上存放的是线程共享的变量（实例字段，静态字段和构成数组的元素），线程的工作内存是线程私有的空间，存放的是线程私有的变量（方法参数与局部变量）。线程在工作的时候如果要操作主内存上的共享变量，为了获得更好的执行性能并不是直接去修改主内存而是会在线程私有的工作内存中创建一份变量的拷贝（缓存），在工作内存上对变量的拷贝修改之后再把修改的值刷回到主内存的变量中去，JVM提供了8中原子操作来完成这一过程：lock, unlock, read, load, use, assign, store, write。
如果只有一个线程当然不会有什么问题，但是如果有多个线程同时在操作主内存中的变量，因为8种操作的非连续性和线程抢占cpu执行的机制就会带来冲突的问题，也就是多线程的安全问题。线程安全的定义就是：如果线程执行过程中不会产生共享资源的冲突就是线程安全的。
多个线程之间是不能直接传递数据进行交互的，它们之间的交互只能通过共享变量来实现。存在成员变量的类用于多线程时是不安全的，不安全体现在这个成员变量可能发生非原子性的操作，而变量定义在方法内也就是局部变量是线程安全的。要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。
多个线程之间是不能直接传递数据进行交互的，它们之间的交互只能通过共享变量来实现。拿上面的例子来说明，在多个线程之间共享了Count类的一个实例，这个对象是被创建在主内存（堆内存）中，每个线程都有自己的工作内存（线程栈），工作内存存储了主内存count对象的一个副本，当线程操作count对象时，首先从主内存复制count对象到工作内存中，然后执行代码count.count()，改变了num值，最后用工作内存中的count刷新主内存的 count。当一个对象在多个工作内存中都存在副本时，如果一个工作内存刷新了主内存中的共享变量，其它线程也应该能够看到被修改后的值，此为可见性。
多个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款，此为有序性。
（2）线程同步机制有三种操作：
<1>.同步代码块
用synchronized关键字可以用于方法中的某个区块中，表示对这个区块的资源实行互斥访问。它是作为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，这一段代码称为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。
一个线程执行临界区代码过程如下：
①        获得同步锁
②        清空工作内存
③        从主内存拷贝变量副本到工作内存
④        对这些变量进行计算
⑤        将变量从工作内存写回到主内存
⑥        释放锁
可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。
运用此方法的时候，在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线性只能在外等着（BLOCKED）。该锁为互斥同步锁，是JVM实现的，可以通过监控工具来监控锁的状态，遇到异常JVM会自动释放掉锁。（ReentrantLock必须由程序主动释放锁。）互斥同步锁都是可重入锁，好处是可以保证不会死锁。但是因为涉及到核心态和用户态的切换，因此比较消耗性能。
<2>.同步方法
使用synchronized修饰的方法就叫做同步方法。
对于public synchronized void add（int num）这种情况，锁就是这个方法所在的对象。如果方法是public static synchronized void add（int num），那么锁就是这个方法所在类的字节码对象。
<3>.锁机制
Lock锁也成同步锁，加锁与释放锁方法化了。
当有许多请求需要去处理的时候，就去线程池里面取出一条线程去处理它，处理完后就把它回收到常量池中。
Lock对象完成的是“同步互斥”工作。用得最多的是重入锁ReentrantLock和读写锁ReentrantReadWriteLock。
①         重入锁ReentrantLock:
在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，不然会造成锁永远无法释放，其他线程永远进不来的结果。
②读写锁ReentrantReadWriteLock:
其核心就是实现读写分离的锁。在高并发访问下，尤其是读多写少的情况下，性能要远高于重入锁。
（synchronized、ReentrantLock，同一时间内，只能有一个线程进行访问被锁定的代码，而读写锁则不同，其本质是分成两个锁，即读锁、写锁。在读锁下，多个线程可以并发的进行访问，但是在写锁的时候，只能一个一个的顺序访问。）
4.Sleep()方法和wait()方法的区别？
答：(1)①进入TIMED_WAITING的一种常见情形就是调用sleep()方法，单独的线程也可以调用，不一定非要有协作关系。
②为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。
③Sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable(可运行)状态。
(2)如果线程在Runnable(可运行)状态中调用了wait()方法，那么该线程就进入了Waiting(无限等待)状态，失去了同步锁。等待另一个线程调用此对象的Object.notify()方法或Object.notifyAll()方法来唤醒，此时，如果获取到了锁对象，那么唤醒后就进入到可运行状态，如果没有获取锁对象，那么就进入到Blocked(锁阻塞状态)。
(3) sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
5.线程有几种状态？他们之间是如何转化的。
（1）线程有六种状态。
（2）①线程刚被创建后，并未启动。处于NEW(新建)状态。
②JVM负责线程的调度。（线程调度是指按照特定的机制为多个线程分配CPU的使用权。JVM的线程调度模式采用了抢占式模式。）当执行thread.start()后，线程处于runnable状态，这种情况下只要得到CPU，就可以开始执行了。
runnable状态的线程，会接受JVM的调度，被调度后就进入running状态，但是具体何时会进入这个状态，是随机不可知的。
③当一个运行的线程调用sleep（）函数时，线程就会进入计时等待状态，当给定的时间到了以后，就会进入运行状态。（sleep()方法只会是否CPU资源，但是不会释放锁。）
④当一个运行状态的线程获得锁对象后，调用了wait()函数后，就进入了无限等待状态，被唤醒后，如果获得了锁，就进入可运行状态；如果被唤醒后没有获得锁对象就会进入阻塞状态。
⑤当一个运行状态的线程获得锁对象后，调用wait(参数)方法后，如果时间到了的时候，获得了锁对象，就会进入可运行状态，如果时间没有到，但是被唤醒了，也可以进入运行状态。如果时间到了，没有获得锁对象，或者时间未到，但被唤醒了，就会进入锁阻塞状态。
⑥当一个运行状态的线程没有获得锁对象就会进入锁阻塞状态。
⑦        当锁阻塞状态的线程获得了锁对象就会进入运行状态。
⑧        被终止状态：根据停止线程时线程执行状态的不同有如下停止线程的方法。
<1>处于运行状态的线程停止
        处于运行状态的线程就是常见的处于一个循环中不断执行业务流程的线程，这样的线程需要通过设置停止变量的方式，在每次循环开始处判断变量是否改变为停止。
<2>即将或正在处于非运行态的线程停止
线程的非运行状态常见的有如下两种情况：
①可中断等待：线程调用了sleep或wait方法，这些方法可抛出InterruptedException异常，然后在循环外捕获并处理这个异常，就可以安全退出。
②Io阻塞：线程调用了IO的read操作或者socket的accept操作，处于阻塞状态。