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

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread 实现Runnable  
继承Thread类
         方式一 创建一个 自定义类 继承 Thread  自定义类 就是一个线程对象
         在该自定义类中 重写了run方法  说明该自定义类 也定义好了 线程任务
         
         使用自定义类对象 调用start方法 开启了新的线程

         为什么不直接使用Thread类 开启线程 非要继承后重写run方法呢？
         
         new Thread().start();//是开启新的线程  但是 没有执行代码 没有意义
            
         查看 Thread中 run方法源码     
            public void run() {
                if (target != null) {
                    target.run();
                }
            }

   方式二  实现Runnable接口
           创建了一个自定义类 实现 Runnable接口  只定义了run()方法  说明该自定义类 就是一个线程(目标)任务类

           创建一个线程对象   将 自定义类对象 作为参数传递 new Thread(线程执行目标);
       

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类 继承Thread 不适合资源共享
    如果实现了 Runnable接口 可以实现资源共享
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        1：多线程程序
        2：多个线程使用同一资源
        3：多个线程对资源有写的操作
        造成了 数据不同步

加锁解决  同步机制
4.sleep()方法和wait()方法的区别？
sleep()方法正在执行的线程主动让出CPU（然后CPU就可以去执行其他任务），在sleep指定时间后CPU再回到该线程继续往下执行(注意：sleep方法只让出了CPU，而并不会释放同步资源锁！！！)；wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行

5.线程有几种状态？他们之间是如何转化的？
NEW
                至今尚未启动的线程处于这种状态。
                新建状态 创建了线程对象 但是还没有调用strat()方法

                RUNNABLE
                正在 Java 虚拟机中执行的线程处于这种状态。
                正在执行的代码，可能分配到了CPU时间片，也可能没分配到，有系统决定。
               
                BLOCKED
                受阻塞并等待某个监视器锁的线程处于这种状态。
                线程A与线程B使用同一把锁，如果线程A拿到了锁，那么线程B就进入了锁阻塞状态

                WAITING
                无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
                一定是在有同步锁对象的时候，调用可wait等不传递时间参数的方法，进入无限等待
                只能依靠另一个同步线程完成唤醒。

                TIMED_WAITING
                等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
                两种情况
                  1：sleep  进入“休眠” 等待时间到了就结束，在等待时间内的状态就是计时等待状态。

                  2：一定是在有同步锁对象的时候，调用可wait等传递时间参数的方法，进入计时等待
                如果在这段时间内 另一个同步线程完成唤醒,那么就唤醒。否则那么就等到这段时间结束 就醒了

                进入等待 醒之前时间内的状态就是计时等待

               
                TERMINATED
                已退出的线程处于这种状态。
                终止状态
                 线程run方法执行完毕 或者遇到未知问题结束的时候

                在给定时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所有操作系统线程状态。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread    创建一个 自定义类 继承 Thread  自定义类 就是一个线程对象
在该自定义类中 重写了run方法  说明该自定义类 也定义好了 线程任务
使用自定义类对象 调用start方法 开启了新的线程
实现Runnable   创建了一个自定义类 实现 Runnable接口 ，创建一个线程对象   将 自定义类对象 作为参数传递 new Thread(线程执行目标);

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承是单继承，实现是可以多实现的
Runnable接口优势：1：适合多个线程共享同一资源 2：避免单继承的局限性3：将线程任务与线程对象进行分离，解耦，增加程序的健壮性 4：线程池中  只能使用Runnable Callable

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
1：多线程程序2：多个线程使用同一资源3：多个线程 对资源有写的操作 造成了 数据不同步
三种方式 1：同步代码块2：同步方法3：Lock锁

4.sleep()方法和wait()方法的区别？
Sleep（）  ：进入“休眠” 等待时间到了就结束，在等待时间内的状态就是计时等待状态。
waiit（）：一定是在有同步锁对象的时候，调用可wait等传递时间参数的方法，进入计时等待如果在这段时间内 另一个同步线程完成唤醒,那么就唤醒。否则那么就等到这段时间结束 就醒了进入等待 醒之前时间内的状态就是计时等待

5.线程有几种状态？他们之间是如何转化的？
New Runnable Blocked Waiting Timed Waiting  Terminated
Blocked线程A与线程B使用同一把锁，如果线程A拿到了锁，那么线程B就进入了锁阻塞状态
Waiting无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。  一定是在有同步锁对象的时候，调用可wait等不传递时间参数的方法，进入无限等待只能依靠另一个同步线程完成唤醒。
Timed Waiting等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。

今天我们进一步学习了多线程，请按照自己的理解回答下面问题：
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种：方式1、创建一个继承Thread类的子类；重写run()方法；创建该子类对象并调用其start()方法启动线程。
方式2、创建一个Runnable接口的实现类；创建该子类对象；把该对象带入Thread(Runnable target)或者Thread(Runnable target,String name)构造方法创建一个Thread类对象；调用该Thread类对象的start()方法启动线程。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
一个是继承自Thread类的子类，本身就是一个线程类代表了一个线程。而Runnable的实现类则是一个线程的任务类，代表了的是一个线程的任务。

Runnable的优势：
Runnable更容易实现相同功能的线程之间的资源共享
避免了Thread所面临的单继承导致代码灵活性大幅下降的问题。
增加了代码的健壮性，实现了代码的解耦，将代码和线程独立，使得代码可以被多个线程共享。
日后如果使用线程池来管理线程，则只能接收Runnable和Callable接口的线程，不能直接放入Thread的子类


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程对成员方法或者静态方法有写操作的时候，可能由于抢占式运行的问题导致各个线程之间的数据不同步从而引发线程安全问题。
解决线程安全可以用线程同步技术来解决，三种方式：使用同步代码块、同步方法、或者Lock接口同步锁。
4.sleep()方法和wait()方法的区别？
sleep()方法是将线程“休眠一段时间”（根据传入的参数作为毫秒数）如果到了时间则唤醒线程。而wait()作为无参则是转入无限等待状态
也可再参数带上时间使其进入计时等待，再其他线程使用notify或者notifyAll时候将其唤醒。
另外sleep()与锁无关，而wait()方法要由锁对象调用。
5.线程有几种状态？他们之间是如何转化的？
六种：
NEW 新建的：一个新创建的尚未启动的线程的状态。
RUNNABLE：可运行的，说明这个线程此时在JVM中可以运行，可能此时正在执行也可能并不在执行其任务，具体跟系统有关。
WAITING:无限等待，线程无限期等待，直到其他线程使用notify或者notifyAll方法来唤醒。
TIMED WAITING 计时等待，在WAITING的基础上加上了计时，计时时间到或在未到时间时收到了其他线程的唤醒操作则线程会被立刻唤醒。
BLOCKED锁阻塞状态，当多个线程共用同一把锁，其他线程持有锁对象执行其人物代码的时候，则未执行的那些线程处于此状态，直到锁被释放后再次争取锁。
TERMINATED 终止状态，当线程的任务代码执行完毕或者遇到没有抛出的异常导致线程被终止的时候，转入此状态。

任何一个线程，创建开始时候都是NEW状态。
在执行了start方法后并且转入RUNNABLE状态。
如果线程没有争取到同步锁，则转入到BLOCKED状态，锁被其他线程释放并被该线程争取到后会转入RUNNABLE状态。
如果该线程使用了wait方法，则转入WAITING状态，在其他线程调用了notify方法后根据是否有获取到同步锁转入RUNNABLE或者BLOCKED状态。
当线程使用了sleep或者带有时间参数的wait方法后会转入TIMED WAITING状态，在收到其他线程的唤醒或者计时时间到以后，根据是否获得了同步锁，决定是转入RUNNABLE或者时BLOCKED状态。
当线程执行完毕，或者中途遇到异常没有捕获导致线程终止的时候，则会转入到TERMINATED状态。

杨银万
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种
第一种，自定义类继承Thread类，重写run方法，将线程要执行的代码写在方法体内，然后创建类对象并调用start方法启动线程
第二种，自定义类实现Runnable接口，实现run方法，将线程要执行的代码写在方法体内，然后创建Thread对象并把自定义类对象当做参数传入构造方法，调用Thread对象的start方法启动线程

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

使用Runnable接口可以让多个线程公用同一个资源
java是单继承多实现的，使用Runnable接口可以增加代码的灵活性，避免单继承的局限性
使用Runnable接口使代码和线程独立，可以增加代码的健壮性，解耦合
线程池中只能放入实现Runnable和Callable接口的线程

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

当多个线程抢占使用CPU时产生的
可以使用同步代码块或同步方法解决线程安全问题

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

sleep方法会使线程进入计时等待状态，计时时间一过线程便被唤醒
wait方法会使线程进入无限等待状态，需要别的线程进行唤醒才会继续执行

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

六种：New新建，Runnable可运行，Blocked锁阻塞，Waiting无限等待，Timed Waiting计时等待，Teminated被终止
线程被创建时处于New新建状态，当调用了start启动方法时，便进入Runnable可运行状态，抢占到了锁对象正在执行的线程也为Runnable可运行状态，线程没有抢占到锁对象处于等待执行时是Blocked锁阻塞状态，当线程调用了wait方法时便进入Waiting无限等待状态，需要被其他线程唤醒，当有其他线程用notify方法唤醒线程时，线程便根据是否抢占到锁对象分别进入Runnable可运行和Blocked锁阻塞状态，当线程调用了sleep方法时便进入Timed Waiting计时等待状态，当计时时间结束或有其他线程用notify方法唤醒线程时，线程便根据是否抢占到锁对象分别进入Runnable可运行和Blocked锁阻塞状态，当线程方法体执行完毕后，便进入Teminated被终止状态。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
extends Thread类,重写run抽象方法,在main方法中创建继承对象,再调用start方法.
implements Runnable接口,创建实现类,重写run方法,在main方法中通过实现类创建实现对象,再new Thread(),参数里传递实现类对象.


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类较为单一,只能单继承,而且不能多个线程执行同一个任务,每个线程的空间都是独立.
实现Runnable接口可以用多个线程执行同个任务,因为是JAVA的多实现体系也比较灵活,增加程序的健壮性和解耦操作.


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程需要同时写一个数据的时候,因为线程之间切换的速度和频率很高,会产生线程安全问题.
可以通过同步代码块,同步方法或lock接口去解决线程安全问题.


4.sleep()方法和wait()方法的区别？
sleep方法是通过Thread去调用的,参数中传递一个毫秒值,在传的值计时结束了后,会继续抢占来执行后面的代码.
wait方法是无限等待,需要通过另一个线程通过new Object对象调用notify方法来唤醒waiting状态下的线程.wait也有一个带参构造也是可以传递毫秒值


5.线程有几种状态？他们之间是如何转化的？
线程有New,Runnable,Blocked,Waiting,Timed Waiting,Terminated,六种状态.
一个线程同时只能有一种状态,新创建出来的线程处于New状态,之后会到Runnable状态,同时又其它线程在执行的话可能会到Blocked状态,其它线程结束会以抢占形式执行.
如果有调用wait方法或timed waiting方法,线程将会暂停执行,直到被唤醒/时间到后重新抢占执行.
terminated则是一个线程运行结束消亡的状态

王宇晨
1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式。
继承Thread类：创建自定义类继承Thread，重写run方法，创建自定义类对象调用start方法，开启新线程。
实现Runnable接口：创建实现类实现Runnable接口，重写run方法，创建实现类对象和线程对象，将实现类对象作为参数传递给线程对象，然后线程对象调用start方法，开启新的线程。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：如果一个类继承了Thread类不适合资源共享，如果实现了Runnable接口可以实现资源共享。
Runnable接口的优势：适合多个相同的程序代码的线程 去共享同一资源
                                     避免了单继承的局限性。
                                     提高了代码的健壮性，实现解耦操作
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题产生原因：多个线程使用同一资源，而且对资源有写的操作，会造成数据不同步。
解决安全问题有三种方式：同步代码块、同步方法、lock锁
4.sleep()方法和wait()方法的区别？
sleep()  进入“休眠” 等待时间到了就结束，在等待时间内的状态就是计时等待状态。
wait()  在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待。
5.线程有几种状态？他们之间是如何转化的？
有六种状态：NEW新建：刚创建还未运行
Runnable可运行：可能运行自己的代码，也可能未运行，取决于系统处理器。
Blocked锁阻塞：当线程获得锁时处于Runnable状态，未获得时处于Blocked状态。
Waiting无限等待：不能够自动唤醒，必须由notify（）或者notifyAll（）方法才能唤醒
Timed Waiting计时等待：这一状态将一直保持到超时期满或者接收到唤醒通知
Teminated被终止：因为run方法正常退出而死亡，或者因为没有捕获的异常终止类run方法而死亡。

贾宗虎

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

两种.
继承Thread:  自定义一个类,继承Thread,在类中重写run()方法,将要在多线程中运行的代码,全部写在run中.在main方法中,创建该子类的对象,并调用start方法运行
实现Runnable接口:  自定义一个类,实现Runnable接口,在类中重写run方法.在main中创建实现类的实例,创建Thread的对象,并在参数列表中,将该实现类传进去.用该对象调用start方法运行

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口比继承Thread的好处:
1.避免单继承的局限性
2.可以是代码更加健壮.
3.线程池中,只能用Runnable和Callable
4.使用多线程共享同一资源

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

产生:  多线程同时间修改同一资源
同步机制(锁机制):  使用同一锁的资源,同一时间只能被一个线程访问
有三种方式
1.同步代码块.2.同步方法.3.lock锁

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

sleep方法是: 线程进入计时等待(Timed Waiting)状态,参数是一个代表毫秒值的数字,倒计时结束后,线程自动唤醒
wait()方法是: 线程进入无线等待(Waiting)状态,直到其他同锁机制的线程执行notify()或notifyAll()方法唤醒.

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

6种.
1.NEW 新建
2.Runnable 可执行
3.Blocked 锁阻塞
4.Timed Waiting 计时等待
5.Waiting 无线等待
6.Terminated 可终止的

首先同一时间点,一个线程只能有一个状态.
先新建线程,程序进入可执行状态,执行的时候,没抢到锁,就进入锁阻塞状态,抢到的话,若果执行到sleep,就进入计时等待状态,结束后,重新进入可执行状态.若执行到wait()方法,就进入无线等待状态,直到其他同一锁机制的线程执行notify或notifyAll唤醒.重新进入可执行状态.执行完所有代码时就是可终止的状态了

郑雪平

今天专门学习了线程方面的内容，主要是学习了多线程。多线程的创建方法有两种，第一种是继承Thread类方法（）；另一种是实现Runnable接口方法。两者都是创建多线程的方法，但是却有着一定的区别。继承Thread类这方法它受到继承只能单一继承的制约，每次调用对象都要生成一个RUN方法，对象和方法捆绑在一起，所以它有很大的局限性，不适合资源共享；实现Runnable接口方法就不一样，它没有继承的局限性制约，可增强程序的健壮性可被多个线程共享，代码和线程是独立的，run方法和对象是分开的可扩展性好等优点。
  多线程在运行时容易发生安全性问题，解决安全性问题的方法有三种：1.同步代码块；2.同步方法；3:lock锁。一.同步代码块使用synchronized 关键字，格式为：synchronized （同步锁）{  同步执行的代码块  }
        二.同步方法:使用synchronized修饰的方法,就叫做同步方法,保证第一个线程执行该方法的时候,其他的线程只能在方法外等待，格式：public synchronized void method(){ 可能会产生线程安全问题的代码 }；三.Lock锁也称同步锁，同步代码块和同步方法具有的功能Lock锁都有,所以它有更广泛的锁定操作也更强大。同步锁: 1. 锁对象可以是任意类型。 2. 多个线程对象只要使用同一把锁。需要明白的是在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 。
  线程状态：线程在被创建出来到结束的生命周期中，总共有六种状态：1.NEW(新建状态)  ；2.Runnable(可运行状态)；3.Blocked(锁阻塞状态)；4.Waiting(无限等待状态)；5.Timed Waiting(计时 等待状态)；6、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方法运行结束，或者因为未捕获的异常而引起的终止程序）

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()方法，创建子类对象
                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的步骤：
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.多线程的实现有几种方式？实现步骤分别是怎样的？
两种。第一种，继承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：创建子类继承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继承类: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.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现有两中方式：
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：建一个新线程类继承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.两种。新建一个类 继承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.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式:
  方式一:

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状态