陈建秋
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.线程有几种状态？他们之间是如何转化的？
线程有6种状态：分别是（1）New新建（2）Runable可运行（3）Blocked阻塞的（4）TimedWating（计时等待）（5）Waiting（无限等待）（6）Termate（终止的）
(1)新建一个线程对象处于可运行状态，如果它抢到了锁对象，就可以运行，如果没抢到就会进入阻塞状态，
(2)当线程抢到锁，通过sleep方法进入TimedWaiting状态，sleep时间结束后进入可运行状态，如果是Wait方法结束那么就需要重新去抢锁，如果抢到就进入可运行状态
没抢到就进入阻塞状态。
（3）当线程抢到锁，通过wait()方法进入无线等待状态，如果被其他线程就需要等待其他线程的唤醒，当其他线程唤醒它时，就需要去抢夺锁，抢到就运行，没抢到进入阻塞
状态。
（4）线程任务运行完线程就被终止。

1.Runnable接口 实现runnable 接口重写run方法.Thread类子类继承thread类, 重写run方法,.
2.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）子类继承Thread 。2） 重写run方法。
3） 创建子类对象。4） 用子类对象调用start方法。使用实现接口的方式创建多线程，
1） 实现类 implements Runnable 。2） 重写run方法。3） 创建实现类对象（线程任务对象）
4） 创建线程对象  new Thread()。 5） 传递线程任务对象 new Thread()。6） 调用线程对象
并调用start方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答： 继承Thread类，线程任务和线程对象绑定在一起。实现Runnable接口实现线程任务和
线程对象分离。
优势：1） 避免了，Java的单继承的局限性
          2） 实现了代码的解耦，可以将线程任务与线程对象进行分离，可以让多个线程对象执行同一个线程任务
          3） 让我们做一些共享数据的操作的前提条件

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候
会发生，数据不符合预期，数据错误。解决线程安全问题，有3种方式.同步代码块，同步方法，实现look接口。

4.sleep()方法和wait()方法的区别？
答：sleep()方法不会释放锁，只是延迟运行时间。wait()方法会释放锁。
5.线程有几种状态？他们之间是如何转化的？
答：6个。NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、
WANTING（无限等待）、TERMINATE（终止）。new到run，有锁对象的直接执行。没有锁对象的就
无限等待，当其他线程通过notify方法调用没有无限等待的对象时。若有锁对象则直接执行，若没有则
到锁阻塞，锁阻塞的对象若争取到锁就执行。有sleep的在获得锁对象后调用wait（）方法到计时等待，
wait时间到判断有没有取到锁。若有则执行，若无则到锁阻塞。

（黄嘉欣）

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接口的优势体现在哪里？
单继承 多接口
避免继承的局限性
避免代码的耦合性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
并发访问同一对象属性，同时通过判断条件
同步代码块 同步方法 Lock锁
4.sleep()方法和wait()方法的区别？
sleep()没有释放锁
wait（）释放锁
5.线程有几种状态？他们之间是如何转化的？
6种
start() sleep()  wait() nodify()

1.多线程的实现有几种方式？实现步骤分别是怎样的？
Thrad，步骤：创建类继承Thrad，重写run方法，run方法里面写需要实现子接口需要实现的代码。
Runnable，步骤：创建Runnable接口实现对象，重写run方法，
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread是Runnable的实现类，Runnable可以资源共享，Thread比较局限性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程同时读取一个共享数据时会发生不可控的，结果不是预期结果
三种：同步代码块，同步方法，LOCK
4.sleep()方法和wait()方法的区别？
Sleep()是有时间限制的，wait(）是永久的需要别人唤醒
5.线程有几种状态？他们之间是如何转化的？
6种，互相转换- -。

a'a'a'a'a'a'a'a'a'a'a'a'a'a'a

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方法，在run方法中打印子线程的名称；
定义一个测试类；
在main方法中打印主线程的名称；
在main方法中创建子线程对象；
调用子线程对象的start方法，开启子线程；
第二种方式：实现Runnable接口
定义一个子任务类，实现Runnable接口；
在子任务类中重写run方法，在run方法中打印子线程的名称；
定义一个测试类；
在main方法中打印主线程的名称；
在main方法中创建一个子任务对象；
在main方法中创建一个Thread类的对象，并把子任务对象传递给Thread类的构造方法；
调用Thread类对象的start方法开启子线程；
2.一个是类一个是接口
实现Runnable接口的优势
适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。
线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
3.
4.线程对象调用run()方法不开启线程，仅是对象调用方法。线程对象调用start()方法开启线程，并让jvm调用run()方法在开启的线程中执行。
5.
NEW(新建) 线程刚被创建，但是并未启动。
Runnable(可运行)
线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)
当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)
一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)
同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)
因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

迪亚波罗 发表于 2018-8-18 21:36
a'a'a'a'a'a'a'a'a'a'a'a'a'a'a

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创建一个类继承Thread

2在类中重写run（）{

方法体中写需要实现的代码的

}

3定义测试方法

创建类中对象.调用stat（）方法开启线程

第二种：

1创建一个runable接口实类

2在实现类中重写run（）方法

3 创建一个接口实现类对象

4在测试类中创建Thread类对象，构造方法中传递runable接口实现类对象

          5调用Thread类中的start方法，开启新的线程执行run方法实现runable接口创建多线
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
    1 避免了继承的局限性

一个类只能extends一个类（一个人只能有一个父亲）

2增强了程序的扩张性 降低了耦合性

3多个任务共享化资源

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制
(synchronized)来解决。
1 . 同步代码块。
2. 同步方法。
3. 锁机制。

4.sleep()方法和wait()方法的区别？
sleep必须是有参  wait可以有参可以无参
   sleep在设定的时间段内不释放锁
   wait会马上释放锁
5.线程有几种状态？他们之间是如何转化

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：当调用start方式时如果抢到锁就运行
3. 阻塞(BLOCKED)：如果没有抢到锁就等状态
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间后会自动唤醒。

6. 终止(TERMINATED)：表示该线程已经执行完毕。

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.多线程的实现有几种方式？实现步骤分别是怎样的？      3种 1 继承Thread类        创建thread的子类        子类中重写run方法        测试类中创建子类对象        测试类中子类对象调用start方法; 2实现Runnable接口        创建runnable接口实现类,实现类中重写run方法        测试类中创建子类对象,创建Thread类对象,并把子类对象作为参数传递进去        thread对象调用start方法 3runnable的匿名内部类        在测试类中new runnable();创建一个匿名内部类,在类里面重写run方法; 2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？        避免了单继承的局限性,一个类只能继承一个类,类继承了thread类就不能继承其他类        增强了程序的扩展性,降低了程序的耦合性(解耦),实现runnable接口的方式,把设置线程任务和开启新线程进行了             分离(解耦),实现类中,重写了run方法,用来设置线程任务,创建thread类对象,调用start方法,用来开启新线程 3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？   多个线程访问共享数据时会可能发生线程安全问题,可以通过线程同步来解决,目前有三种,分别是同步代码块,同步方法,Lock锁 4.sleep()方法和wait()方法的区别？ Sleeo方法使线程陷入睡眠,在睡眠期间线程任然在调用cpu,且不释放同步锁,wait方法则在让线程处于waitting状态时停止对CPU的调用,并释放同步锁 5.线程有几种状态？他们之间是如何转化的？ 6种状态   1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 2. 运行(RUNNABLE)：当调用start方式时如果抢到锁就运行 3. 阻塞(BLOCKED)：如果没有抢到锁就等状态 4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。 5. 时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间后会自动唤醒。 6. 终止(TERMINATED)：表示该线程已经执行完毕。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
Thread：1、创建Thread的子类；2、重写run（）方法；3、创建子类对象；4、调用start（）方法；
runnable：1、创建runnable的实现类；2、重run（）方法；3、创建实现类对象，并把此对象作为Thread的target来创建Thread对象；4、调用start（）；
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Runnable将创建进程任务与创建进程分开。
1、避免了单继承的局限性；
2、增加了程序的拓展性，降低程序的耦合性；
3、共享数据的前提；
3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
多个进程执行同一个进程任务时（修改，写）一个全局变量或静态方法就有可能发生安全问题。
同步代码块。同步方法。锁机制Lock
4.sleep()方法和wait()方法的区别？
sleep有睡眠时间，满足条件自动解锁。wait（）只加锁。解锁需notify()。
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.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()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。

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

实现Runnable接口：是创建线程任务对象  然后将任务对象通过构造方法传入thread对象中

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

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

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

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
安全问题：共享一个线程的时候，涉及到多个线程操作（修改、写的的操作）一个全局或者静态的资源数据的时候会发生数据不符合预期，数据错误。
4.sleep()方法和wait()方法的区别？
sleep 是进入 计时等待
wait  是进入无线等待
5.线程有几种状态？他们之间是如何转化的？
6种状态： 1. new 创建  2.runnable 可运行  3. time_wait 计时等待  4.wait 无线等待  5. Blocked(锁阻塞） 6.Teminated 终止
(1)新建一个线程对象处于可运行状态，如果它抢到了锁对象，就可以运行，如果没抢到就会进入阻塞状态，
(2)当线程抢到锁，通过sleep方法进入TimedWaiting状态，sleep时间结束后进入可运行状态，如果是Wait方法结束那么就需要重新去抢锁，如果抢到就进入可运行状态
没抢到就进入阻塞状态。
（3）当线程抢到锁，通过wait()方法进入无线等待状态，如果被其他线程就需要等待其他线程的唤醒，当其他线程唤醒它时，就需要去抢夺锁，抢到就运行，没抢到进入阻塞
状态。
（4）线程任务运行完线程就被终止。

1.子类继承Thread类，子类重写run方法，子类对象调用start方法开启新线程
.实现类实现Runable接口 ，实现类重写run方法，创建Thread对象，将实现类对象作为传参传入，Thread对象调用start方法
2.Runnable接口  解耦，将线程任务和线程开启过程分离
突破继承的单继承的局限性，实现类可以继承多个接口
实现数据共享
3.共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候 会发生，数据不符合预期，数据错误。同步方法  静态同步方法  锁机制  加锁 和 释放锁
4.sleep方法是自定义暂停时间，时间过后会继续执行，锁不释放，wait方法是无限停止，只有当别的线程使用notify方法才能继续执行，停止过程中会释放锁
5.NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、WANTING（无限等待）、TERMINATE（终止）

1.多线程的实现有几种方式？实现步骤分别是怎样的？两种
创建多线程的第一种方式：创建Thread类的子类
1、创建一个继承Thread的子类，并重写run()方法
2、创建Thread子类的对象
3、通过对象调用start方法，系统会自动调用run()方法
创建多线程的第二种方式，实现Runnable接口
1、创建一个Runnable接口的实现类
2、在实现类中重写Runnable接口的run方法，设置线程任务
3、创建Runnable接口实现类对象
4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5、Thread类对象调用start方法启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1、避免了单继承的局限性
2、增强程序的健壮性，实现解耦操作，把设置线程任务和开启新线程进行了分离（解耦）
3、线程池只能放实现Runnable和Callabe的类，不能直接放入Thread的类
4、实现多个线程去共享同一个资源。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程共同执行同一个线程任务的时候，涉及增删改资源数据的时，由于java的抢占式执行的不可控性时会发生，数据与预期结果不同

4.sleep()方法和wait()方法的区别？
sleep()方法执行时，当前线程以指定毫秒数暂停，不会释放锁
wait()方法执行时会释放锁，且若没有设定等待时间，线程会进入无限等待，除非其他线程唤醒才会继续执行，调用wait方法的对象必须为锁对象

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

六种
new 新建、Runnable 可运行、Blocked 锁阻塞、Waiting 无限等待、Timed Waiting 计时等待、Teminated 被终止
线程刚被创建，但是并未启动时为新动状态
线程被启动、或等待线程被唤醒、或者睡眠线程的睡眠时间到达时，会转为可运行状态
试图获取某个同步锁时，锁被其他线程持有，转为阻塞状态
当调用了wait()方法时并且没有设定等待时间转化为无限等待状态
当调用了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的实现类，在main方法中调用；

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

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


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

当多线程运行，写入时，数据不同步导致线程不安全
有两种解决方式：I、使用syn.......方法，通过同步锁来解决
II、使用Lock方法获取锁，来进行线程同步，解决线程安全问题

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

sleep方法是自定义暂停时间，时间过后会继续执行，锁不释放，wait方法是无限停止，只有当别的线程使用notify方法才能继续执行，停止过程中会释放锁

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

6种状态
新建、运行、阻塞、等待、无线等待、终止