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

刘慧梅
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式
（1）：继承Thread
/创建自定义类 继承Thread
/重写run方法 写新的线程执行代码
/创建对象调用start方法  开启新的线程
（2）：实现Runnable接口
/创建实现类实现Runnable接口,重写run()方法
/创建Runnable的实现类对象
/创建Thread的对象 在构造方法里传递Runnable的实现类对象
/线程对象调用start()方法，开启一个线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类是单继承的，实现Runnable接口是可以共享同一资源。
实现Runnable接口的优势：
/创建多个线程同时执行一个任务，共享同一资源
/避免java中单继承的局限性
/增强程序的健壮性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程同时执行或线程共享同一资源时会产生线程安全问题，造成数据不同步
解决线程安全问题有三种方式：
/同步代码块
/同步方法
/Lock锁
4.sleep()方法和wait()方法的区别？
调用sleep()方法进入休眠状态
wait()方法分两种，带参的wait()方法是可以被唤醒的。无参的Wait()方法如果没有获取锁对象，那将进入无限等待状态
5.线程有几种状态？他们之间是如何转化的？
分为六种
/New   创建线程，未启用
/Runnable  可运行
/Blocked   阻塞
/Waiting   无限等待
/Timed Waiting   计时等待
/Teminated  被终止

创建线程为New，运行为Runnable。能不能运行就看有没有获取锁对象，如果获取了锁对象就Runnable，没有获取锁对象就Blocked。
对象锁调用wait()方法进入Waiting等待状态，调用notify()方法唤醒
调用sleep()方法进入Timed Waiting计时等待状态
线程任务完成后被终止Teminated

吴佳更
1.两种，Runnable和Thread
Thread直接new一个对象，重写run方法，通过对象名调用start开启双线程。
Runnable通过new一个Runnable对象，把对象作为参数传入Thread再new一个对象，重写run方法，通过对象名调用start开启多线程。
2.
适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类
3.使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题
有三种方式，一种同步代码块，一种同步方法。一种lock锁。
4.sleep只能进入Time Waitting状态，而无参的wait能进入waitting状态，只能等notify或notifyAll唤醒。有参的wait也可以进入Time Waitting状态，而sleep和有参的wait也可以等时间到了可以自然醒。
5.6种。new是刚创建的线程并未启动。
            Runnable是可运行状态，可能运行也可能还没运行。
            Waitting是等待状态，通过wait方法进入。可以通过notify或者notifyAll唤醒。
            Time Waitting是时间等待状态，可以通过sleep和有参的wait方法进入。
            Blocked如果一个对象试图获得对象锁，而对象锁有对象持有，这时候就会进入Blocked状态，如果获得锁就会进入Runnable状态
            Teminated因为run方法正常退出而死亡，或者没有捕捉异常终止了run方法而死亡。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
  第一种为创建Thead的子类,重写run方法,然后创建该子类对象.
  第二种为实现Runnable接口,重写run方法,创建该实现类的对象,然后创建Thead对象并将Runnable实现类对象传入Thead对象的构造方法.
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
  继承只能单继承而接口可以多实现,所以使用Thread的代码耦合高,实现Runnable接口则可以提高代码的健壮性.而且Runnable接口可以实现同一任务的多线程并发运行
,因为Thread类带有含Runnable实现类对象的参数,可以提高程序的运行效率.
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
  线程安全问题是由于线程并发共享资源的时候数据读取重复或者,一个线程进行读操作,另一线程进行写操作.就造成了数据不同步.
解决安全问题的方式有三种:同步代码块,同步方法,创建Lock锁.
4.sleep()方法和wait()方法的区别？
sleep方法是延时,wait方法是休眠,需要别的线程唤醒,也可以给具体的休眠时间.
5.线程有几种状态？他们之间是如何转化的？
有六种状态:New,Runnable,Blocked,Waiting,Timed Waiting.
New是新建未start的状态,terminated则是一个线程终止的状态,Blocked状态是其他线程持有锁的时候此时线程的阻塞的状态,wait是无限等待的状态需要调用wait方法,需要设置休眠时间或者需要唤醒,Timed Waiting是计时等待一般需要设置时间,除了这几种状态就是Runnable状态

林梅源
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式：继承Thread类和实现Runnable接口
继承Thread类：创建一个自定义的类extends Thread，重写run()方法，自定义的类创建一个对象，
调用run（）方法；
实现Runnable接口：自定义一个类实现Runnable接口，重写run()方法，将要执行的线程全都写在run（）里面，在main方法中，子类创建对象，调用run（）方法。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类继承Thread类，则不适合资源共享，如果是实现Runnable接口的话，则很容易的实现资源共享。
优势：避免了单继承的局限性；
        多个相同的程序代码的线程去共享一个资源。
        增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
        线程池只能放入实现Runnable或Callable类线程，不能放入直接继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
如果有多个线程在同时运行，而这些线程可能同时运行这段代码。程序每次运行结构和单线程运行的结果是一样的额，而且其他变量的值也和预期的是一样的，就是线程安全。
三种解决方式：同步代码块；同步方法；同步锁。
4.sleep()方法和wait()方法的区别？
sleep()是让线程睡眠多长，时间到了自然会苏醒，wait()是让线程停止，必须去唤醒，没有被唤醒的话，会一直等待下去。
5.线程有几种状态？他们之间是如何转化的？
6种
new 新建
runnnable 可运行
Blocked 锁阻塞
Waiting 无限等待
Timed Waiting 计时等待
Teminated 被终止

1.一种是继承Theread，自定义一个类让它继续Theread，重写run方法将要的功能写到方法体里，在main的方法里new一个子类对象，并调用start方法运行。另一种是实现Runnable接口，自定义一个类让它实现Runnable接口，重写run方法将要的功能写到方法体里，在main的方法里new一个实现类在new一个Theread带参数的把实现类对象名放入参数列表，用Theread对象名去调用start方法。

2.继承Theread是单继承的，而Runnable是可以多实现的，优势：适合多个线程共享同一资源 避免单继承的局限性 将线程任务与线程对象进行分离，解耦，增加程序的健壮性  线程池中  只能使用Runnable Callable。

3.存在两个或者多个的线程对象共享同一个资源，操作共享数据的线程代码多条，当一个线程操作共享数据的过程中，其他线程也参与了运算，就会导致线程的安全问题。解决方式有三种：1.同步代码块 2.同步方法 3.lock锁。

4.sleep（）方法可以让线程计时等待参数是毫秒值当计数结束时就会继续运行下面的代码。wait（）无参数的是无限休眠的直到另一个线程执行notify方法是才会被唤醒参与其他线程的抢栈。wait（）带参数的也是在这毫秒值结束的时候就会与其他线程参与抢栈有概率会继续执行接下来的代码也会抢不到就锁阻塞了。

5.6种 1.new新建 2.Runnable可执行 3.Blocked锁阻塞 4.Timed Waiting计时等待 5.Waiting无线等待 6.Terminated可终止的 总之在给定时间点上，一个线程只能处于一种状态。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现方式有两种，一种是通过继承Thread ,然后继承父类的run()方法，在主方法new子类的对象，再通过   对象名.start();开启线程
还有一种是实现

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

接口可以多实现，而继承只能是单继承
优势体现在以下四点：
1、适合多个相同程序代码的线程共享一个资源
2、可以避免单继承的局限性
3、增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
4、线程池只能放入Runnable或Callable类线程，不能直接放入继承Thread类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
单多个线程同时访问一个资源时，就会产生线程安全问题，可以通过给线程加锁的方式
来实现线程安全问题，共有三种方式.第一种：synchronize代码块  第二种：synchronize方法
第三种：lock锁对象


4.sleep()方法和wait()方法的区别？

sleep()是计时休眠，时间到了会自动苏醒。而wait()如果在没有notify得到另一线程的notify是不会被唤醒的


5.线程有几种状态？他们之间是如何转化的？
线程有六种状态。
新创建的线程通过start()进入Runnable可运行状态，在没有获取锁对象的时候是处于Blocked锁阻塞状态，如果获取
到了就会进入可运行状态，如果获取锁状态的时候调用了wait方法，那么就会进入无线等待当中，直到有其它线程调用
notify方法，如果调用notify后，还是没获取到锁，那么就还是进入锁阻塞状态，如果获取到锁了，就进入可运行状态，
直到用户结束线程，也就会进入线程的消亡期Teminate.

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

继承Thread类，写一个有参构造，重写run方法，main方法内创建对象，
对象调用start方法；
实现接口Runnable,重写run方法，创建Runnable的实现类对象，把Runnable
的实现类对象传递给Thread对象的参数，用Thread的对象调用start方法。

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

继承Thread类属于单继承，在创建对象的时候只能启动一次线程；
实现Runnable接口可以实现多个相同程序的代码的线程共享同一份资源，
避免单继承的局限性，增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，
代码和数据独立。


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

产生原因：多个相同程序的代码的线程共享同一份资源，而且对资源中的变量
有写的操作，造成打印效果与预期不一致。
通过线程同步解决：同步代码块；同步方法；Lock锁

4.sleep()方法和wait()方法的区别？

sleep只有等毫秒值过后才可以运行，wait如果设有毫秒值，一旦被唤醒就会立即执行
，不会等毫秒值结束，如果没有被唤醒，将会继续沉睡。

5.线程有几种状态？他们之间是如何转化的？

New 只是创建了新的线程对象，还没调用strat方法；
Runnable 运行状态，取决于系统；
Blocked 锁阻塞，多个线程处于运行状态是，如果没有获得同步锁对象就处于锁阻塞状态；
Waiting 无限等待状态，如果对象锁.wait没有参数，需要另一个线程去唤醒，一旦被唤醒如果没有
获得同步锁对象将处于锁阻塞状态；
Timed Waiting  休眠状态，取决于sleep 的毫秒值；
Terminated  终止状态，如果当前线程运行全部代码或者出现未知问题时。

1.多线程的实现有几种方式？实现步骤分别是怎样的？两种方式：
a. 创建继承Thread的子类，重写里面的run方法，在主程序创建子类对象（也可使用匿名内部类创建），调用start方法开启线程；
b.创建Runnable实现类，重写里面的run方法，在主程序创建实现类对象（也可使用匿名内部类创建），再通过有参构造方法创建Thread对象传入参数Runnable实现类对象。之后通过Thread的对象调用Start方法开启线程；

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类不适合多线程共享资源
实现Runnable接口可以实现多线程共享资源；
优势：
可以被多个线程所共享，并且线程和代码是相对独立的
避免了单继承的局限性
提高了程序的健壮型，更符合高内聚低耦合思想；
线程池中指能放置Runnable和Callable线程，无法直接放入Thread线程


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题产生的三个前提：
                 多线程程序；
                 多线程共享资源；
                 对资源进行写的操作；
多线程操作同一资源，导致资源数据不同步。

可通过同步机制（锁机制）解决线程安全问题
解决方式三种：
一。同步代码块:
                 synchronized(同步锁对象){
                 可能产生线程安全问题的代码块
                 }
二。同步方法
                 将关键字synchronized写在方法上
格式：
                 修饰符  synchronized  返回值  方法名（）{
                 }
三。Lock锁
                 创建Lock对象，通过对象调用lock方法放置于可能出现线程安全问题的代码块前面，再在末尾调用unlock方法；
                 Lock l  = new Lock;
                 l.lock();
                 可能产生线程安全问题的代码块
                 l.unlock;

4.sleep()方法和wait()方法的区别？
调用sleep方法只是让线程休眠指定时间，处于计时等待状态，倒计时结束后，线程会被唤醒；而wait方法则是使线程永远处于等待状态，除非有其他线程调用notify方法或者notifyAll方法唤醒，此时锁对象在唤醒线程中，被唤醒的线程将处于BLOCKED状态

5.线程有几种状态？他们之间是如何转化的？

六种状态：
                 NEW（新建）  刚创建线程未调用start方法开启是的状态，开启后则是RUNNABLE状态；
                 RUNNABLE（可运行）  线程正常运行执行任务时的状态
                 BLOCKED（锁阻塞）   锁阻塞状态，AB两个线程共享一个锁对象，当锁对象被A获取到时，B则处于锁阻塞状态
                 WAITING（无限等待）  无期限等待状态，该线程永远处于等待中状态，除非有其他线程调用notify方法或者notifyAll方法唤醒，此时锁对象在其他线程中，被唤醒的线程将处于BLOCKED状态
                 TIMED_WAITING（计时等待）    计时等待状态，倒计时时间内处于等待状态，倒计时结束后唤醒（或者被其他线程提前唤醒），唤醒时若没有获取到锁对象，则进入锁阻塞状态
                 TERMINATED（终止）  线程正常退出    线程执行完run方法后退出的状态，又或者是执行run方法过程中出现异常而未捕获导致程序终止而退出的状态
注意：
                  同一时间点一个线程只能处于一种状态

吴香斌


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

1. 创建一个自定义类继承Thread类

2. 重写Thread类的run方法

3. 创建自定义类对象,并调用start方法,便启动了一个新的线程.

方式二:

1. 创建一个自定义类实现Runnable接口

2. 重写Thread类的run方法

3. 创建自定义类对象,并把自定义对象作为Thread类构造方法的参数,创建Thread对象.

4. 使用Thread对象调用start方法,便启动了一个新的线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口是先创建Runnable接口实现类对象,然后把接口对象作为Thread类构造方法的参数,创建Thread对象,接下来步骤和直接继承Thread类方法一样.
实现Runnable接口的优势:
1. 适合多个相同的程序代码的线程实现资源共享
2. 避免Java中的单继承的局限性
3. 增加程序的健壮性,实现解耦操作
4. 线程池只能放入实现Runnable或Callable类线程,不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
主要是针对全局变量和静态变量而言,在多线程程序中,多个线程使用同一资源,可能存在改写的操作,容易造成数据的不同步
三种方式; 1. 同步代码块  2. 同步方法  3. 同步锁机制

4.sleep()方法和wait()方法的区别？
sleep方法是提供时间参数的暂停方法,在时间达到或者被提前释放,线程都会被唤醒.
wait()方法分为体提供时间参数和不提供时间参数的暂停方法,前者和sleep是一样的,或者若没有被提前释放,则会无限期暂停下去.

5.线程有几种状态？他们之间是如何转化的？
线程有6种状态.
1. New状态 ---->(调用start方法)  Runnable运行状态
2. Runnable状态  --->(运行结束)  Teminated停止状态
   Runnable状态  --->(未获取到锁)  Block锁阻塞
   Runnable状态  --->(无时间参数的wait方法)  Waiting无限等待
   Runnable状态  --->(有时间参数的wait方法/sleep方法)  Timed Waiting计时等待
3. Block锁阻塞 --->(获取到锁) Runnable运行状态
4. Waiting无限等待 --->(被唤醒未获得锁) Block锁阻塞
   Waiting无限等待 --->(被唤醒且获得锁) Block锁阻塞
5. TimeWaiting及时等待 --->(计时等待时间到/被唤醒 ,且获得锁) Runnable状态
   TimeWaiting及时等待 --->(计时等待时间到/被唤醒 ,但未获得锁) Runnable状态

1.两种。新建一个类 继承Thread类，重写run（）方法，里面写线程要执行的
  代码，创建类对象，调用start（）方法启动。
  一个类实现Runnable类，定义run方法，在里面的run方法里写要执行的代码，
  创建Runnable对象，然后将Runnable对象放进new Thread（）里.start();启动
2.继承Thread类只能单继承，资源单一使用；实现Runnable接口可多实现，资源能够共享。
  优势:多线程可以共享同一资源；
       避免单继承的局限性；
       将线程对象跟线程任务是独立的，能多线程共享，增加程序的健壮性；
       适用线程池。
3.多线程程序；多个线程使用同一资源；多个线程对资源有写的操作
  造成的数据不同步
  三种方法：同步方法块；同步方法；lock锁。
4.sleep()方法是用Thread调用，wait()方法是靠Lock锁调用；sleep()方法
跟wait()方法加入参数都是休眠一段时间，wait()方法不加参数就是无限等待。
5.六种状态。NEW新建状态，就是创建了线程，但还没有调用start方法；
  BUNNABLE状态，就是正在执行的代码；BLOCKED锁阻塞状态，多线程使用通一把锁，
  若一线程拿到锁，其他就陷入锁阻塞状态；WAITING无限等待状态，在有同步锁对象
  时，调用wait方法无参就是进入无限等待状态；TIMED_WAITING计时等待状态，在用
  Thread调用sleep方法传参跟wait方法传参，在传入的指定时间到等待执行就是计时
  等待；TERMINATED终止状态，线程结束终止时。

王博

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

继承Thread：建一个新线程类继承Thread类，重写run方法，然后创建该类的对象，通过对象名.start()方法开启线程
实现Runnable：建一个新线程类实现Runnable接口，创建该实现类对象，创建Thread类对象，传入参数为创建的实现类对象名，通过创建的Thread对象名.start()开启线程
还可直接用匿名内部类的方式


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Java中只能单继承，通过继承Thread，该类就局限于Thread,降低了可拓展性
Java中可以多实现，通过实现Runnable，该类还可以进行其它拓展，可以多个线程共享同一资源，可以实现代码的低耦合，提高代码健壮性
       还有线程池中只能使用Runnable,Callable


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

多个线程共享同一资源，并且会对其进行更改，就会出现线程安全问题
可通过线程同步机制家解决，有三种方式：同步代码块，同步方法和Lock锁

4.sleep()方法和wait()方法的区别？
sleeep()方法是让线程进入计时等待，通过Thread直接调用，不受同步机制影响
wait()方法是让线程进入无限等待，必须通过另一个线程调用notify()或notifyAll()方法唤醒，而且wait()方法只能在同步机制中使用，必须通过锁对象调用
wait()方法中还能传递参数，变成计时等待，如果有另一个线程调用notify()或notifyAll()方法，就会被唤醒，如果没有，就会等到时间结束自动唤醒

5.线程有几种状态？他们之间是如何转化的？
NEW：线程创建了，但没通过调用start()开启线程
RUNNABLE：线程进入可运行状态
BLOCKED：同步中，当线程1获取锁，开始运行，线程2就处于这种状态，锁阻塞
WAITING：线程进入无限等待中，必须通过另一个线程通过特殊方法才能唤醒
TIMED_WAITING：计时等待状态，计时结束就会唤醒
TERMINATED：终止状态，线程run方法执行完毕或者遇到未知问题结束的时候

彭东亮
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现有两中方式：
1、继承Thread类：
（1）、定义一个Thread类的子类，重写Thread类中的run()方法，该方法体是线程需要完成的任务，因此称为线程的线程执行体；
（2）、建立对象，调用子类，利用start()方法来启用线程
2、实现Runnalble接口；
（1）、定义一个实现类来实现Runnalble接口，重run方法；
（2）、建立对象，调用实现类，并调用Thread类中的target来创建一个Thread对象，它才是线程的主体；
（3）利用start()方法来启用线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类不适合进行资源共享，且具有单继承的局限性；实现Runnable接口能够实现资源贡献，避免了单继承的局限性；
优势：（1）、适合多个相同代码程序共享一个资源；
（2）、避免了Java中的单继承的局限性；
（3）、线程池中只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
（4）、提高可程序的健壮性，解除耦合，代码可以被多个线程共享，代码和数据独立；
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当我们使用多个线程使用同一资源时，并对资源有写的操作，就容易产生线程安全问题；
有三中方式可以解决线程安全问题：1、同步方法块；2、同步方法；3、Lock锁
4.sleep()方法和wait()方法的区别？
wait()方法用于唤醒等待，需要另外一个线程使用notif或者notifyAll来进行唤醒操作，sleep()方法用于计时等待，当wait()方法包含参数时也可以用于计时等待，时间到了就能唤醒，也可以用另外一个线程使用notif或者notifyAll来进行唤醒操作
5.线程有几种状态？他们之间是如何转化的？
线程有6种状态，分别为：New(新建)、Runnable(可运行)、Blocked(锁阻塞)、timed waiting(计时等待)、waiting(唤醒等待)、teminated(被终止)
New(新建)为刚建立的线程，并且还未使用start()方法进行启用，当启用后则会进入到Runnable(可运行)状态；当线程在进入到Runnable(可运行)状态时如果未抢到对象锁则进入到Blocked(锁阻塞)状态，抢到对象锁则进入Runnable(可运行)状态中运行代码；当线程获得对象锁后调用wait()方法后，线程会进入到waiting(唤醒等待)状态，需要由另外一个程序使用notify或者notifyAll进行唤醒操作，当线程被唤醒但未获得对象锁，线程则会进入到Blocked(锁阻塞)状态，被唤醒后获得对象锁则进入到Runnable(可运行)状态；当线程调用sleep()方法或者获得对象锁调用wait(参数)，线程则进入到timed waiting(计时等待)状态，当时间到了或者被notify或notifyAll唤醒后得到对象锁则进入到进入Runnable(可运行)状态中运行代码，如果没获得对象锁则进入到Blocked(锁阻塞)状态；当线程因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡则进入到teminated(被终止)状态。

林焕

1.Thread继承类:1.自定义类继承Thread;
               2.重写自定义类中run()方法;
               3.创建自定义类的对象;
               4.自定义类对象调用start()方法开启线程;

Runnable实现类:1.定义实现类实现Runnable;
                2.重写实现类中run()方法;
                3.创建实现类的对象;
                4.实现类的对象作为参数创建Thread对象;
                5.Thread对象调用start()方法开启线程;

2.继承Thread类体现了继承体系中的单继承性;
  实现Runnable接口可以让线程实现资源共享;

实现Runnable接口优势:1.可以实现多线程资源共享;
                     2.避免了单继承的局限性;
                     3.将线程任务与线程对象进行分离,解耦,增加了程序的健壮性;
                     4.线程池中只能使用Runnable Callable;

3.线程安全问题的产生是指:多线程程序中多线程共享同一资源,并对资源有写的操作,产生了数据不同步现象;
   解决线程安全有3种方式:1.同步方法块;
                         2.同步方法;
                         3.lock锁;

4.sleep()方法和wait()方法的区别:

sleep()方法:进入“休眠” 等待时间到了就结束，在等待时间内的状态就是计时等待状态;

wait()方法:一:wait()不传递时间参数，进入无限等待只能依靠另一个同步线程完成唤醒;
           二:wait()传递时间参数，进入计时等待;如果在这段时间内另一个同步线程完成唤醒,那么就唤醒;否则那么就等到这段时间结束就醒了;

5.线程状态:1.new(新建):新建后进入runnable状态;

        2.runnable(可运行):拿到锁对象后线程执行;

        3.waiting(等待):等待其他线程调用notify()方法唤醒进入锁阻塞状态,否则一直处于等待状态;

        4.timed waiting(时间等待):等待时间结束,进入锁阻塞状态;
                                  或者其他线程调用notify()方法使其进入锁阻塞状态;

        5.blocked(锁阻塞):线程获得锁对象后执行该线程;

        6.teminated(结束):

==========迷人的反派角色林传伟================
1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread：创建子类继承Thread 重写run()方法，创建子类对象，调用start()方法开启线程
实现Runnable：创建接口Runnable接口实现类，重写run方法，创建实现类实例，以实现类实例作为Theard的target创建Thread对象，调用start()方法开启线程

都可通过匿名内部类方式实现多线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
类继承Thread不适合资源共享，Runable接口很容易的实现资源共享。

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


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

4.sleep()方法和wait()方法的区别？
调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)，不需要唤醒，
waiting()需要唤醒

5.线程有几种状态？他们之间是如何转化的？
new runnable blocked timedwaiting waiting terminated

洪文生
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种。第一种，继承Thread类方式，定义一个类继承Thread类并且重写run（）方法，方法中就写线程体的代码，之后新建自定义类的对象并调用start()方法启动线程
第二种，实现Runnable接口方式，定义一个类实现该接口，并且重写run()方法，方法中就写线程体的代码，之后新建该类的对象，并以该对象作为参数（target）用Thread（target）方法建立线程对象并调用start（）方法。除此之外也可以不写Runnable的实现类，直接用匿名内部类的方式来创建线程对象。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
优势：1，多个线程程序可以共享同一资源。2，避免了单继承的局限性。3，线程对象和线程代码独立，实现了低耦合性，增强了健壮性。4，线程池只能放Runnable类或者Callable类线程，不能放继承Thread类线程

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享同一资源时，并且对该资源进行写的动作时，会产生线程安全问题。
利用锁机制，也就是同步机制来解决线程安全问题。
方式一：同步代码块，synchronized（同步锁）{可能产生线程安全的代码}
方式二：同步方法，修饰符 synchronized 返回值类型 方法名（参数）{可能产生线程安全的代码}
方式三：Lock锁，通过new ReentrantLock对象，用该对象调用lock（）方法和unlock方法，将可能出现线性安全问题的代码放在两个方法中间。

4.sleep()方法和wait()方法的区别？
sleep（）方法通过Thread类名直接调用，sleep（）方法使线程在指定的时间内进入WAITING状态，在指定的时间结束后直接进入Runnable状态；wait（）方法通过同步锁对象调用，使线程进入无限等待状态，知道另外一个线程利用用一个同步锁对象调用notify（）方法才能唤醒

5.线程有几种状态？他们之间是如何转化的？
六种。NEW新建状态：线程对象创建后，没有调用start方法前
Runnable运行状态：线程在执行过程中，但是并不代表在Runnable状态线程就一定在执行，具体得看系统的cpu调度
BLOCKED阻塞状态：线程A和线程B同步并且使用同一个同步锁时，线程A执行的话，就代表线程A获取了同步锁，线程B就是BLOCKED状态
Waiting无线等待状态：线程同步并且同步锁对象调用wait（）方法使线程进入无限等待状态，只有当另外一个同步线程用同一个同步锁调用notify（）方法后才会被唤醒，被唤醒的线程在唤醒后并不直接进入Runnabled状态，因为被唤醒的那刻，程序执行还在另一线程的同步块中，也就代表同步锁还在另一线程中，所以被唤醒的线程的状态会由WAITING转为BLOCKED状态。之后，只有当被唤醒的线程抢到同步锁时才会进入Runnable状态
Timesd Waiting计时等待：调用sleep（时间参数）方法，在指定时间内为等待状态，相当于暂停，当指定时间结束后直接进入Runnable状态
Teminated被终止状态：线程正常结束，或者线程运行过程中遇到异常没有捕获处理而非正常结束

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式 一种是继承Thread 一种是接口Runnable
继承Thread的步骤：
1.定义类继承Thread
2.创建这个类的对象 并且调用Start()方法来开启多线程
接口Runnable的步骤：
1.定义自定义类实现Runnable
2.创建这个接口的实现类对象 创造Thread的对象 并且在Thread的对象中传递Runnable的实现类对象
3.线程对象调用Start()方法开启多线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类 代码没有拓展性 因为是单继承的
实现Runnable接口 java是允许多实现的 并且可以多个线程执行同一个任务

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题的产生是因为多线程涉及到共享资源的删改引发的
使用同步机制可以解决线程安全问题 保证线程安全以及同步性
有3种方式
1.同步代码块
2.同步方法
3.Lock锁

4.sleep()方法和wait()方法的区别？
sleep()方式是属于Thread类的方法
wait()方式是属于Lock接口的方法
调用sleep方法让当前执行的线程进入休眠状态 方法参数传递的是毫秒值

调用wait方法是让当前的线程进入无线等待状态 需要另外一个线程调用notify方法 唤醒无线等待的线程


5.线程有几种状态？他们之间是如何转化的？
线程有六种状态
new新建 未启动的线程
Runnable 正在java虚拟机中执行的线程

BLOCKED 受阻塞的线程 如果抢占到锁 继续运行
Waiting 无线等待状态 等待另外一个线程唤醒才可以继续运行
Timed Waiting 计时等待 计时器一到即可运行 或者其他线程唤醒他了 也可以继续运行
Termincted 已退出的线程

黄希

1.多线程的实现有几种方式？实现步骤分别是怎样的？
        线程的创建方式有三种：
                1、继承Thread类，重写run()方法，创建子类对象
                2、实现Runnable接口，重写run()方法，创建实现类对象，再通过public Thread(Runnable target)构造函数创建线程类对象
                3、使用匿名内部类的方式实现Runnable接口，通过public Thread(Runnable target)构造函数创建线程类对象

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        实现Runnable接口的优势：
                1、多个线程使用同一资源
                2、避免单继承的局限性
                3、代码可以被多个线程共享，代码与线程独立，实现解耦，增加程序的健壮性
                4、线程池只能放Runnable接口或Callable接口的实现类，不能放继承Thread类的子类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        多个线程同时操作同一个资源，造成数据不一致。
       
        采用同步机制解决线程安全问题，有三种方式：
                1、同步代码块
                        synchronized(锁对象){}
                2、同步方法
                        修饰符 synchronized 返回类型 方法名(参数列表){}
                3、Lock锁
                        Lock lock = new ReentrantLock();
                        lock.lock();//加锁
                        lock.unlock();//释放锁

4.sleep()方法和wait()方法的区别？
        sleep()方法是计时休眠，时间到，继续执行后面的代码；
        wait()方法是无限休眠，等待唤醒，并争取到锁，才能执行后面的代码。
       
5.线程有几种状态？他们之间是如何转化的？
        线程有6种状态：
                NEW                        新建线程，还未启动
                RUNNABLE                正在运行的线程
                BLOCKED                        受阻塞，正在等待监视器锁的线程
                WAITING                        正在无限等待的线程
                TIMED_WAITING        正在计时等待的线程
                TERMINATED                已终止的线程
               
        线程创建后，状态为new；
        启动线程后，状态为runnable；
        多个线程争取锁对象，没有争取到的状态为blocked，争取到的状态为runnable；
        获取到锁对象后，调用wait()方法后，状态为waiting，等待其他线程调用notify()方法，唤醒该线程，唤醒后并获取到锁对象，状态为runnable，如果没有获取到锁对象，状态为blocked；
        runnable状态下的线程，调用sleep()方法或wait(long timeout)方法，进入timed_waiting状态；
        timed_waiting状态下的线程等待sleep时间到，或者wait时间到并获取到锁，再或者wait时间未到，被其他线程唤醒并获取到锁，则进入runnable状态，如果没有获取到锁，则进入blocked状态；
        线程中的任务执行完毕后，状态为terminated。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式 继承Thread 和实现 Runnable
继承Thread
创建Thread类的子类，重写run()方法  创建该类对象 调用start()方法
实现Runnable
创建类继承Runnable  重写run()方法  作为参数传递给 Thread 对象，调用start()方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类 单继承 局限，
多线程共享统一资源
将线程与对象分离
线程池 只能使用Runnable Callable
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程对同一资源进行读写操作产生数据不同步
三种方式  同步代码块、同步方法、同步锁
4.sleep()方法和wait()方法的区别？
sleep()使当前线程进入block状态
wait()使当前线程进入waiting状态
5.线程有几种状态？他们之间是如何转化的？
6种状态 new runnable  block waiting timed waiting teminated
线程创建未调用start（）方法为 new状态，调用后为runnable状态，
调用wait()方法进入waiting 状态 调用wait()带参方法后进入 timed waiting 状态
wait状态的线程被notify() nitifyAll（）方法调用后 未获得锁则是block状态，线程结束则是teminated状态

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

多线程的实现有两种方式。
（1）通过继承Thread类重写run方法，然后创建继承的子类，调用start()方法创建线程。
（2）通过实现Runnable接口，三步曲：     1.创建Runnable的实现类
                                                                   2.通过Thread带参构造方法创建Thread线程类
                                                                   3.调用Thread对象的start方法开启线程         

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

继承Thread类只要创建子类对象进行调用start()方法就可以完成线程的开启了。 而实现了Rnnable接口的子类对象，需要调用Thread的构造方法在去创建Thread对象才能调用start方法从而完成线程的开启。
实现Runnbale的优势：
1）便于多个线程访问同一资源
2）规避了Java的单继承特性。
3）能够增强程序的健壮性。
4）在线程池中只能放入Rnnable和Callable的实现类对象，而不能直接放入Thread的对象。

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

产生：当多个线程对同一资源进行读写操作时，就会出现一个线程在进行读，而一个线程在进行写，在读操作进行到一半时，线程就切换到写操作上，那么写入的数据就会出现错误！

解决安全问题有三种方式，分别是：
（1）通过同步代码块解决
（2）通过同步方法解决
（3）通过Lock锁解决

4.sleep()方法和wait()方法的区别？

sleep是Thread的方法，sleep是让线程休眠指定毫秒后，自动苏醒。而wait()方法是锁的方法，被wait的线程需要同一锁对象的notify方法进行唤醒。

5.线程有几种状态？他们之间是如何转化的？

线程有六种状态分别是，新建态，运行态，阻塞态，等待状态，定时等待状态，消亡态。
新建态----->运行态（线程被开启）
运行态----->等待态（调用wait方法）
等待态----->运行态（被notify方法唤醒，并且获取了锁的执行权）
等待态----->阻塞态（调用notify方法）
阻塞态----->运行态（获取了锁对象）
运行态----->定时等待（sleep(毫秒值),wait(毫秒值)）
定时态----->运行态（睡眠毫秒值时间到了或者其他线程调用了notify方法）
运行态----->消亡态（run方法运行结束，或者因为未捕获的异常而引起的终止程序）