1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种；第一种继承类 ：1.定义一个类 extends Thread ，并重写run()方法；
                   2.run()方法内编写线程任务代码
                   3.在主线程main方法内创建该类对象
                   4.使用对象名称调用start方法启动线程；
      第二种实现类：1.定义一个实现类 implement Runnable ，并重写run()方法
                   2. run方法内编写线程任务代码
                   3.在主线程main方法内创建该实现类的对象
                   4.创建 new Thread 对象接收 该类对象(该对象引用才是线程任务对象)
                   5.使用 new Thread 对象名调用start方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：Runnable 创建的对象还需要创建 Thread对象接收成为线程任务；
优势体现：1） 避免了，Java的单继承的局限性
            2） 实现了代码的解耦，可以将线程任务与线程对象进行分离，可以让多个线程对象执行同一个线程任务
           3） 让我们做一些共享数据的操作的前提条件
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候
    会发生，数据不符合预期，数据错误。
解决方式：1）同步代码块
         2）同步方法
         3）lock方法
4.sleep()方法和wait()方法的区别？
sleep()方法 ： 只是让线程以定义的毫秒值的时间段暂停运行，并且不释放同步锁
wait()方法 ：  在调用wait方法时，意味着该线程时无线等待状态，想要恢复需要其他线程调用notify方法唤醒，
              唤醒还需要再次争抢同步锁；且会释放同步锁
5.线程有几种状态？他们之间是如何转化的？
有六种状态;
创建new：调用stars方法
运行状态：多线程情况下，有同步锁的情况下，保持运行状态
锁阻塞状态：多线程抢夺一个同步锁时，没有抢到的线程，处于阻塞状态
无线等待状态：持有同步锁，但是被wait方法催眠了，处于无线等待状态，该状态需要另一个线程执行唤醒（notify）动作
计时等待状态: 只暂停一段时间后自动运行的，一般使用sleep方法
终止状态：所有线程停止

//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：创建Thread的子类，并重写run方法，创建子类对象并调用start方法。
Runnable：创建Runnable的实现类，并重写run方法，创建实现类的实例（r），创建线程对象（r）并调用start方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Runnable的实现类对象只是线程目标，并非线程对象。
1.Thread单继承的局限性
2.Runnable方便共享。
3.程序的健壮性及解耦。
4.线程池可以放Runnable的实现类，不能存放Thread子类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程执行同一任务时出现与单线程不一样的结果。
通过线程同步。
同步代码块/同步方法/锁机制

4.sleep()方法和wait()方法的区别？
sleep（）是短暂停止，过了既定时间后且获得锁对象即可变成运行状态，不会释放锁对象。
wait方法会释放锁对象，且她必须有人用notify方法唤醒才有可能进入运行状态。

5.线程有几种状态？他们之间是如何转化的？
6种。NEW新建/RUNNABLE可运行/WAIT无限等待/即使等待/锁阻塞/终止

1.多线程的实现有几种方式？实现步骤分别是怎样的？ （1）子类继承Thread，重写run方法，创建子类对象，调用start方法 （2）实现Runable,重写run方法，创建实现类对象，创建Thread传入实现类，调用start 2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？ 实现Ruanable可以共享资源，将线程任务代码和线程对象分开，还可有继承别的类 T继承hread不能共享资源，不能再继承别的类 3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？ 多个线程一起去修改或者写共享的全局变量及静态数据时，得到的数据不符合预期 4.sleep()方法和wait()方法的区别？ sleep让线程进入计时等待，切不会放出锁对象，别的线程不能得到锁对象 wait（），不传参数时，线程进入无线等待，带别的线程唤醒，传入参数时进入计时等待，会放出锁对象 5.线程有几种状态？他们之间是如何转化的？ 6中转态，新建，可运行，锁阻塞：当超过设定时间，或被唤醒，终止等待，如获取了锁对象，则进入可执行状态，否在进入阻塞。，计时等待，无线等待：一个线程进入Waiting状态，没有其他线程唤醒，无则处于等待状态。唤醒后如获取了锁对象，则进入可执行状态，否在进入阻塞。，被终止

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种，一种继承thread，首先子类 extends Thread，然后在 重写run方，法然后在 创建子类对象，最后用子类对象名调用start方法。另种采用runnable接口的实现类，重写run方法，在主方法中创建实现类对象，创建线程对象 用new Thread()，再把传递线程任务对象传到已经创建的线程对象中，用线程对象调用start()方法。     

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable线程对象,对象中的线程任务可以被多个线程对象应用。而继承Thread的子类线程对象只能被它自己引用。
好处：1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。
4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
   
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
   共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候会发生，数据不符合预期，也就是数据错误。
  三种：1、采用同步代码块
2、采用同步方法
3、采用锁机制
4.sleep()方法和wait()方法的区别？
Sleep()到了等待的时间结束就会运行，作用是防止线程运行过快或者自定义运行时间，不会释放锁，waite()的调用必须要有锁对象来调用，并且会释放锁。
5.线程有几种状态？他们之间是如何转化的？
  有6个。NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、
WANTING（无限等待）、TERMINATE（终止）。创建对象的时候就是New，调用start方法就会开启线程进入RUNNABLE，多个线程运行时，没有锁对象的会进入BOLCKED、遇到sleep方法会进入及时等待，遇到waite()方法会进入无线等待，释放锁对象，因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡就是TERMINATE

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种，一种是将类声明为 Thread 的子类，重写run()方法,创建子类对象调用start()方法;
第二种声明一个类实现Runnable 接口，重写run()方法,创建实现类对象作为线程任务，作为参数来创建Thread对象调用start()方法。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
可以避免java中的单继承的局限性
增加程序的健壮性，实现解耦操作，
适合多个相同的程序代码的线程去共享同一个资源。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
是在多个线程修改一个任务的数据时产生的。可以用安全代码块、安全方法、锁机制三种方式。
4.sleep()方法和wait()方法的区别？
sleep()方法是定时休眠不会释放锁，wait()是无限等待，需要其他线程唤醒。会释放锁。
5.线程有几种状态？他们之间是如何转化的？
6种：new，runnable，blocked，waiting，time-waiting，teminated

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式：1、通过继承Thread类，实现run()方法，创建子类对象，调用start()方法。
2、通过实现runnable接口，覆盖重写run()方法，创建线程传入Runnable类对象，调用start()方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread类封装了对象个执行方法；Runnable将执行方法抽取出来。
Runnable接口优势是解耦。


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

4.sleep()方法和wait()方法的区别？
sleep不释放锁，wait（）释放锁

5.线程有几种状态？他们之间是如何转化的？
新建状态 new
运行状态 Runnable
阻塞状态 blocked
无限等待期 waiting
计时休眠期 time_waiting
死亡状态 terminated

新建后去抢占锁资源，如果抢到进入运行状态，没有抢到的进去阻塞状态

lijionghua

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

1多线程实现有两种方式。
第一种是通过创建子类继承Thread类
步骤：1创建子继承类2重写run方法3创建子类对象4子类对象调用start方法
第二种是通过实现先Runable接口
步骤：1创建接口实现类2重写run方法3创建实现类对象4创建Thread对象传入实现类对象作为参数5调用start方法。
2继承Thread类线程任务和线程绑定一个对象创建一个线程
实现Runnable接口线程任务可以和线程分开，一个实现类对象可以开启多个线程
实现Runnable接口优势在于避免单继承局限性，增强程序扩展降低程序耦合性
3共享一个线程任务是若是涉及多个线程进行操作容易出现数据重复，数据错误等异常
解决线程安全可以使用同步代码块。同步方法，lock锁三种方式。
4sleep()方法使线程进入一段时间的休眠，在此期间线程不会释放同步锁。
而wait()方法使线程进入无限等待并且释放同步锁给其他线程。
5线程有6个状态
new新建线程
runable运行线程 执行程序直到程序终止
Bolcked阻塞 线程进入阻塞直到线程夺取锁对象返回运行线程
Timed-Waiting计时等待 线程进入休眠时间，休眠时间结束返回运行
Waiting无线等待 线程进入无线等待，其他线程拿取锁对象，直到线程被唤醒，若是直接唤醒后直接夺取到锁对象则返回运行否则进入线程阻塞。
Terminate终止
================================================  周楠

1.多线程的实现有几种方式？实现步骤分别是怎样的？
一、继承类
子类 extends Thread
重写run方法
创建线程对象
调用start方法         
二、实现接口
创建实现类
重写run方法
创建线程任务
创建线程对象
调用star方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
避免单继承的局限性
增强程序的扩展新，降低程序的耦合性（解耦）；
实现Runnable接口方式，把设置线程任务和开启新线程分离（解耦）
可以让多个线程对象执行同一个线程任务
实现类中，重写了run方法：用来设置线程任务
创建Thread对象，来调用start()方法：来开启新线程。
让我们做一些数据共享的任务

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
结果和单线程不一样
Java中提供了同步机制 (synchronized)来解决
有三种方式完成同步操作：

同步代码块。
同步方法。
锁机制。
4.sleep()方法和wait()方法的区别？
wait 方法释放锁

5.线程有几种状态？他们之间是如何转化的？
NEW 至今尚未启动的线程处于这种状态。 (未启动start方法)
RUNNABLE 正在 Java 虚拟机中执行的线程处于这种状态。
BLOCKED 受阻塞并等待某个监视器锁的线程处于这种状态。 （未抢占到锁,等待锁释放抢锁）
WAITING 无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
TIMED_WAITING 等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。(sleep()方法)
TERMINATED 已退出的线程处于这种状态。

周家乾

1.多线程的实现有几种方式？实现步骤分别是怎样的？
    2种。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Runnable接口是对Thread总run方法的抽取,实现Runnable能降低类与类的耦合度,使用更加灵活。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题是由于多线线程在对同一资源进行读写操作时，会发生与预期不相符的情况。
（1）同步代码块（2）同步方法（3）lock锁机制
4.sleep()方法和wait()方法的区别？
Sleeo方法使线程陷入睡眠,在睡眠期间线程任然在调用cpu,且不释放同步锁,wait方法则在让线程处于waitting状态时停止对CPU的调用,并释放同步锁。
5. 线程有几种状态？他们之间是如何转化的？
NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、WANTING（无限等待）、TERMINATE（终止）。

------------------吴齐宾-------------------------
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种,
1)继承Thread类
继承Thread类,然后创建子类的对像,重写run方法有子类的对象名去调用start();
2)实现Runnable接口
实现Runnable接口,重写run的方法.然后创建实现类的对像,将对像放入Thread方法中当做参数,得到一个对像返回值,将返回的对像去调用start方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1)实现Runnale更适用于多个线程去调用同一个的资源
2)没有继承Thread类的局限性
3)将线程和任务分离,实现解耦性

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
1)线程安全问题是因为我们调用多个线程去改写同一资源,导致我们得到的结果和我们预期的结果或者单线程的结果不一致
2)使用线程同步synchronized解决线程安全问题
3)有三种方式,1.同步代码块
                      2.同步方法
                      3.锁机制
4.sleep()方法和wait()方法的区别？
sleep()方法,是带锁休眠,当时间到了之后会自动带锁去cpu争夺资源
wait()方法是将锁抛出,任务停止,等待别的程序去唤醒,唤醒之后还要继续和其他的线程争抢锁,才能进入任务代码块
5.线程有几种状态？他们之间是如何转化的？
有6种状态,开始,运行,停止,阻塞,睡眠等待,无线等待

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread类 重写run方法 在测试类创建继承类对象 .start；
实现Runnable接口 重写run方法 在测试类中创建Thread类对象 创建Runnable接口实现类对象  将实现类对象作为Thread类对象的参数 .start；
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类重写run方法只能由该继承类对象运行该任务
实现Runnable接口重写run方法 可以将实现类对象 赋值给多个线程,如果一个线程故障了 还有多个线程继续执行任务
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程执行同一个任务会产生xian'c
使用同步代码块、同步方法、锁机制 可以解决该问题
4.sleep()方法和wait()方法的区别？
sleep方法等待时间结束后不释放锁
wait方法无参时是无限等待并释放锁，只有唤醒后才能加入抢锁行列
wait方法可以有计时等待
5.线程有几种状态？他们之间是如何转化的？
新建
可运行
阻塞
无限等待
记时等待
终止

1.多线程的实现有几种方式？实现步骤分别是怎样的？
三种
1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start


2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
是因为JAVA是抢占式运行多线程的，当一个线程的执行任务还没结束时，就被其他线程抢走了，导致删除和更改操作的数据出现异常
有五种解决方法，一、同步代码块，二、同步方法，三、静态同步方法，四、lock、unlock方法，五、wait、notify方法
4.sleep()方法和wait()方法的区别？
wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
5.线程有几种状态？他们之间是如何转化的？
六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种，一种是继承thread类，重写run方法，创建thread类子类对象，用子类调用start方法开启线程。第二种是实现runnable接口，重写run方法，创建接口子类对象，创建thread对象把接口子类对象写入thread参数里，用thread对象调用start方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
解决继承的单一性，解耦
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程操作同一资源并且有写操作，有三种方式，1同步代码块2同步方法3rock锁
4.sleep()方法和wait()方法的区别？
sleep方法不释放锁，wait方法释放锁
5.线程有几种状态？他们之间是如何转化的？
六种状态，刚创建没有调用start方法就是创建状态，调用start方法有锁对象进入可运行传统，没有锁对象进入阻塞状态，使用wait会进入无限等待状态，被唤醒如果有锁对象进入可运行状态，没有锁对象进入阻塞状态，使用sleep方法会进入睡眠等待状态，没有释放锁，当时间到了如果有锁对象进入可运行状态，运行状态结束进入销毁状态