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.多线程的实现有几种方式？实现步骤分别是怎样的？

继承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.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现方式有两种，一种是通过继承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.一种是继承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类和实现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.多线程的实现有几种方式？实现步骤分别是怎样的？
  第一种为创建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.两种，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.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式
（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