1.Runnable接口 实现runnable 接口重写run方法.Thread类子类继承thread类, 重写run方法,.
2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
4.sleep()程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁.
   wait线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
5.创建:线程刚被创建，但是并未启动。还没调用start方法.
可运行:线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器,
锁阻塞,:当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
无限等待:一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
计时等待:同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
被终止:因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread 重写run方法  创建子类的对象   子类调用start开启
接口Runnable  重写run方法  创建子类对象  子类对象传递给Thread参数  Thread对象调用start开启
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread是Runnable的实现类，Runnable可以资源共享，Thread比较局限性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程同时读取一个共享数据时会发生不可控的，结果不是预期结果
三种：同步代码块，同步方法，LOCK
4.sleep()方法和wait()方法的区别？
sleep()没有释放锁
wait（）释放锁
5.线程有几种状态？他们之间是如何转化的？
6种：new，runnable，blocked，waiting，time-waiting，teminated；

1.Runnable接口 实现runnable 接口重写run方法.Thread类子类继承thread类, 重写run方法,.
2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
4.sleep()程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁.wait线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
5.创建:线程刚被创建，但是并未启动。还没调用start方法.
   可运行:线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器,
        锁阻塞,:当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
        无限等待:一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
        计时等待:同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
        被终止:因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

1.Runnable接口 实现runnable 接口重写run方法.Thread类子类继承thread类, 重写run方法,.
        2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
        3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
        4.sleep()程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁.
        wait线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
        5.创建:线程刚被创建，但是并未启动。还没调用start方法.
        可运行:线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器,
        锁阻塞,:当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
        无限等待:一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
        计时等待:同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
        被终止:因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

1.Runnable接口 实现runnable 接口重写run方法.Thread类子类继承thread类, 重写run方法,.
        2.Thread只能继承一个类实现了Runnable的类,还可以继承其他接口 优势在于1.避免java单继承性2.实现代码解耦3.共享数据前提.4.代码和线程独立
        3.多线程运行的结果和单线程运行的结果不一样,不符合我们的预期.使用线程同步来解决.同步代码块,同步方法,静态同步方法
        4.sleep()程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁.
        wait线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
        5.创建:线程刚被创建，但是并未启动。还没调用start方法.
        可运行:线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器,
        锁阻塞,:当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
        无限等待:一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
        计时等待:同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
        被终止:因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

//1.多线程的实现有几种方式？实现步骤分别是怎样的？
//        三种
//        1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
//        2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
//        3.new一个接口子类在其中new线程接口并且重写run方法
//        2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
//        区别在于将重写和调用分开了，可操作性加强了
//        3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
//        多线程对一变量进行同时操作，使用锁，三种，同步代码块，同步方法，Lock锁
//        4.sleep()方法和wait()方法的区别？
//        wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
//        5.线程有几种状态？他们之间是如何转化的？
//        六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式：子类继承Thread 实现类实现Runnable 实现Runnable要创建Thread对象为线程对象，实现类对象为线程任务对象
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread在数据需要共享时不能用，实现Runnable提高代码灵活性。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程进行写操作时的结果与单线程不一致，产生线程问题。解决线程问题，使用同步代码块和同步方法和Lock锁
4.sleep()方法和wait()方法的区别？
sleep方法不释放锁，wait方法会释放锁
5.线程有几种状态？他们之间是如何转化的
NEW新建/RUNNABLE可运行/Blocked阻塞/WAITING无限等待/TimedWaiting即使等待/teminated终止1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式：子类继承Thread 实现类实现Runnable 实现Runnable要创建Thread对象为线程对象，实现类对象为线程任务对象
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread在数据需要共享时不能用，实现Runnable提高代码灵活性。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程进行写操作时的结果与单线程不一致，产生线程问题。解决线程问题，使用同步代码块和同步方法和Lock锁
4.sleep()方法和wait()方法的区别？
sleep方法不释放锁，wait方法会释放锁
5.线程有几种状态？他们之间是如何转化的
NEW新建/RUNNABLE可运行/Blocked阻塞/WAITING无限等待/TimedWaiting即使等待/teminated终止

孙享

余志斌
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种，一种通过继承。 创建Thread的子类重写run方法。new子类对象以此调用start方法。
          一种通过实现。 创建Runnable的实现类重写run方法。new实现类对象，以此作为参数new Thread对象，通过Thread对象调用start方法。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
单继承、多实现。
避免单继承的局限性。可以实现线程任务和线程建立分离，降低耦合度，实现多线程任务共享。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
是在多个线程修改一个任务的数据时产生的。可以用安全代码块、安全方法、锁机制三种方式。
4.sleep()方法和wait()方法的区别？
sleep是该线程自身休眠，是有参、不释放锁的方法，条件满足自动苏醒。
wait是无限等待，需要其他线程唤醒。会释放锁。
5.线程有几种状态？他们之间是如何转化的
6种。 新建状态（刚new）  ，通过start方法 进入run状态，以判断是否有锁判断是否进出locked状态。timewait ，执行该方法时从run进入，方法执行完毕退出至run。wait，执行该方法时从run进入，被唤醒时退出至run。 terminated，执行完毕时终止。

1.继承Thread类重写run方法  创建子类的对象   子类调用start开启
接口Runnable重写run方法  创建子类对象  子类对象传递给Thread参数  Thread对象调用start开启
2.一个是类一个是接口
3.线程安全问题是由于多线线程在对同一资源进行读写操作时，会发生与预期不相符的情况。
4.sleep（）可以设置睡眠时间，不能主动释放锁
调用wait()方法，线程属于Waiting状态，并会将锁释放掉
5.new，runnable，waiting,blocked，time-waiting，teminated六种

//1.多线程的实现有几种方式？实现步骤分别是怎样的？
//        三种
//        1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
//        2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
//        3.new一个接口子类在其中new线程接口并且重写run方法
//        2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
//        区别在于将重写和调用分开了，可操作性加强了
//        3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
//        多线程对一变量进行同时操作，使用锁，三种，同步代码块，同步方法，Lock锁
//        4.sleep()方法和wait()方法的区别？
//        wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
//        5.线程有几种状态？他们之间是如何转化的？
//        六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束

1.多线程的实现有几种方式？实现步骤分别是怎样的？
          多线程的实现由两种方式：1.继承Thread类 2.实现Runnable接口
      1.（1）定义一个类继承Thread类
        （2）重写run方法，将线程代码逻辑写到run方法中
        （3）在测试类中创建子类对象，子类对象调用start()方法开启线程
      2.（1）创建类实现Runnable接口，重写run方法将线程代码逻辑写到run方法
（2） 创建实现类对象（线程任务对象）
            （3）创建线程对象  new Thread()
            （4） 传递线程任务对象 new Thread()
            （5） 调用线程对象(第4创建的)调用start方法



2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
      区别：如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
          实现Runnable接口的优势体现在以下四个方面：
          1. 适合多个相同的程序代码的线程去共享同一个资源。
          2. 可以避免java中的单继承的局限性。
          3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
          4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
     线程安全：多个线程运行的结果和单线程程序运行的结果一致，结果是我们预期的结果
     三种方式解决线程安全问题：1. 同步代码块。2.. 同步方法。3. 锁机制。
4.sleep()方法和wait()方法的区别？
              Sleep()方法是计时等待，时间到了自动唤醒
              wait()方法是无限等待，需要专门调用方法唤醒
5.线程有几种状态？他们之间是如何转化的？
         线程有6种状态，分别是NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、WANTING（无限等待）、TERMINATE（终止）

         田浪

//1.多线程的实现有几种方式？实现步骤分别是怎样的？
//        三种
//        1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
//        2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
//        3.new一个接口子类在其中new线程接口并且重写run方法
//        2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
//        区别在于将重写和调用分开了，可操作性加强了
//        3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
//        多线程对一变量进行同时操作，使用锁，三种，同步代码块，同步方法，Lock锁
//        4.sleep()方法和wait()方法的区别？
//        wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
//        5.线程有几种状态？他们之间是如何转化的？
//        六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束

1.        多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread类重写run方法，创建子类对象，子类对象调用start方法
实现Runnable接口，重写run方法，创建实现类对象，创建线程对象并传入实现类对象，线程对象调用start方法
2.        继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口可以由多个线程处理一件事情，继承Thread无法实现
避免了，Java的单继承的局限性， 实现了代码的解耦，可以将线程任务与线程对象进行分离，可以让多个线程对象执行同一个线程任务，让我们做一些共享数据的操作的前提条件
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
共享一个线程任务的时候，涉及到多个线程操作（写的操作）一个全局的或者静态的资源数据的时候会发生，数据不符合预期，数据错误。
同步代码块、同步方法、lock锁
4.sleep()方法和wait()方法的区别？
Sleep()方法在休眠时间后会进入运行状态，不会释放锁
Wait()方法是长期休眠，需要用notify()方法来唤醒，会释放锁
5.线程有几种状态？他们之间是如何转化的？
New（新建）线程刚被创建，但是并未启动
Runnable（运行）线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器
Bolcked（阻塞）当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态
Timedwaiting（计时等待）同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.waitWaiting（无限等待）一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
Teminated（终止）因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡

//1.多线程的实现有几种方式？实现步骤分别是怎样的？
//        三种
//        1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
//        2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
//        3.new一个接口子类在其中new线程接口并且重写run方法
//        2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
//        区别在于将重写和调用分开了，可操作性加强了
//        3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
//        多线程对一变量进行同时操作，使用锁，三种，同步代码块，同步方法，Lock锁
//        4.sleep()方法和wait()方法的区别？
//        wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
//        5.线程有几种状态？他们之间是如何转化的？
//        六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread 和 实现Runnable接口 都需要重写run方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
根据单继承多实现原理，继承Thread的类的线程的线程任务只能自己执行，不可以共享
实现Runnable接口，其实最后也需要new 新的线程来执行线程任务，但是可以共享，
优势；
            1.适合多个相同的程序代码的线程共享一个资源
            2.可以避免java中的单继承的局限性
            3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
            4.线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程访问同一资源时，程序运行的结果可能和单线程运行的结果不同，也就是与预期不符

有三种方式解决：1. 同步代码块。 2. 同步方法。 3. 锁机制。

4.sleep()方法和wait()方法的区别？
sleep时计时等待，wait时时无限等待
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
5.线程有几种状态？他们之间是如何转化的？
六种
new创建线程
run可运行，多个线程竞争锁对象，当有一个线程a得到锁对象时，其余线程会进入Blocked锁阻塞，等待a执行完，如果a在执行资源时，调用wait方法那么会进入无限等待，那么会释放锁，其他的线程可以继续竞争锁对象，如果调用计时等待，要么等待时间到，并获取锁执行资源，要么时间到或时间未到但被唤醒，没有得到锁，进入锁阻塞，等待竞争。资源全部运行结束后被终止

//1.多线程的实现有几种方式？实现步骤分别是怎样的？
//        三种
//        1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
//        2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
//        3.new一个接口子类在其中new线程接口并且重写run方法
//        2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
//        区别在于将重写和调用分开了，可操作性加强了
//        3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
//        多线程对一变量进行同时操作，使用锁，三种，同步代码块，同步方法，Lock锁
//        4.sleep()方法和wait()方法的区别？
//        wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
//        5.线程有几种状态？他们之间是如何转化的？
//        六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方法可以实现：
（1）继承Thread类，重写run()方法，创建子类对象。
（2）实现runable接口，重写run()方法，创建接口子类对象，创建Thread类对象，将线程任务传递给线程对象。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
（1）Runable接口适合多线程资源的共享；
（2）Runable接口可以解决单继承的局限性；
（3）Runable接口可以实现解耦操作；
（4）线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类；
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题是由于多线线程在对同一资源进行写的操作时，会发生与预期不相符的情况。
（1）同步代码块
（2）同步方法
（3）lock锁机制
4.sleep()方法和wait()方法的区别？
调用用sleep()方法，线程处在TimedWaitng状态，并且持有锁，其他线程无法进入。
调用wait()方法，线程属于Waiting状态，并会将锁释放掉。
5.线程有几种状态？他们之间是如何转化的？
1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：当调用start方式时如果抢到锁就运行
3. 阻塞(BLOCKED)：如果没有抢到锁就等状态
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间后会自动唤醒。
6. 终止(TERMINATED)：表示该线程已经执行完毕。

郭林源

1.多线程的实现有几种方式？实现步骤分别是怎样的？--->2种，第一种子类继承Thread类，重写run方法，然后创建子类对象，子类对象调用star方法开启新线程；第二种是实现runable接口，重写run方法，然后创建实现类线程任务，再新建Thread对象，传入线程任务，再用Thread对象调用star方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？--->java只能单继承多实现，所以用继承方法开启多个新线程时，须新建多个子类，实现Runnable接口则不用，并且实现Runnable接口还可以把设置线程任务和开启新线程进行了分离，降低耦合

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？--->线程安全是多个线程运行的结果与单个线程运行不一样，过程中可能常量会被修改和写入。解决办法，第一种同步机制synchronized，第二种LUCK锁

4.sleep()方法和wait()方法的区别？--->sleep是进入休眠状态，但休眠后程序还在执行。wait是休眠后结束程序

5.线程有几种状态？他们之间是如何转化的？--->6种状态，new--新建程序时启动，run--线程对象调用star方法后，并且线程抢到同步锁对象后进入run，没抢到的线程进入阻塞，等进入run的方法执行结束后，重新抢同步锁对象，调用wait方法后，进入无限等待阶段，等另一个线程调用notify方法后，激活进入无限等待的线程，用sleep或wait方法后进入计时等待阶段，sleep休眠时间结束后，线程继续进行，wait是休眠时间结束后，结束线程

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

两种方式：

1.创建子类继承Thread类，重写run方法，通过子类对象调用.start()启用新线程；

2.通过子实现类实现Runnable接口，通过Runnable接口的实现类对象作为Thread的target来创建Thread对象。

   通过Thread对象调用start()方法启动新线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？

1.实现Runnable接口避免了单继承的局限性 。类继承了Thread类就不能再继承其他类，实现Runnable接口还可以继承其他类，实现其他接口。

2.增强了程序的扩展性,降低了程序的耦合性(解耦)。 实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

实现线程安全问题的方法有三种：

1.使用同步代码块

2.使用同步方法

3.lock锁机制

4.sleep()方法和wait()方法的区别？
sleep（）可以设置睡眠时间，不能主动释放锁；
wait（）除非被唤醒否则无限等待，可以主动释放锁；
5.线程有几种状态？他们之间是如何转化的？
六种状态：
NEW(新建)、Runnable(可运行)、Blocked(锁阻塞)、Waiting(无限等待)、TimedWaiting(计时等待)、Teminated(被终止)
(1)新建一个线程对象处于可运行状态，如果它抢到了锁对象，就可以运行，如果没抢到就会进入阻塞状态，
(2)当线程抢到锁，通过sleep方法进入TimedWaiting状态，sleep时间结束后进入可运行状态，如果是Wait方法结束那么就需要重新去抢锁，如果抢到就进入可运行状态
没抢到就进入阻塞状态。
（3）当线程抢到锁，通过wait()方法进入无线等待状态，如果被其他线程就需要等待其他线程的唤醒，当其他线程唤醒它时，就需要去抢夺锁，抢到就运行，没抢到进入阻塞
状态。
（4）线程任务运行完线程就被终止。

//1.多线程的实现有几种方式？实现步骤分别是怎样的？
//        三种
//        1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
//        2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
//        3.new一个接口子类在其中new线程接口并且重写run方法
//        2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
//        区别在于将重写和调用分开了，可操作性加强了
//        3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
//        多线程对一变量进行同时操作，使用锁，三种，同步代码块，同步方法，Lock锁
//        4.sleep()方法和wait()方法的区别？
//        wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
//        5.线程有几种状态？他们之间是如何转化的？
//        六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束