黑马程序员技术交流社区
标题: 【厦门JavaEE就业三期-每日总结】线程、同步 [打印本页]
作者: 厦门校区 时间: 2018-8-18 20:52
标题: 【厦门JavaEE就业三期-每日总结】线程、同步
1.多线程的实现有几种方式？实现步骤分别是怎样的？
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
5.线程有几种状态？他们之间是如何转化的？
作者: sulaymanfan 时间: 2018-8-18 21:13
标题: yefan
1.多线程的实现有几种方式？实现步骤分别是怎样的？ 有两种方式:
1 . 子类继承thread类, 重写run方法,.
2. 实现runnable 接口重写run方法.
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Runnable接口是对Thread总run方法的抽取,实现Runnable能降低类与类的耦合度,使用更加灵活
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程同时读取一个共享数据时会发生不可控的数据异常,
可以使用互斥锁, synchronized代码块 和 synchronized方法
4.sleep()方法和wait()方法的区别？
sleep必须是有参 wait可以有参可以无参
sleep在设定的时间段内不释放锁
wait会马上释放锁
5.线程有几种状态？他们之间是如何转化的？
1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：当调用start方式时如果抢到锁就运行
3. 阻塞(BLOCKED)：如果没有抢到锁就等状态
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间后会自动唤醒。 6. 终止(TERMINATED)：表示该线程已经执行完毕。
作者: 郭生发 时间: 2018-8-18 21:18
1.多线程的实现有几种方式？实现步骤分别是怎样的？
2种。
通过将类声明为Thread的子类。定义Thread的子类，重写run方法，方法体为线程要完成的任务。创建Thread的子类的对象也就是线程对象，通过线程对象调用star方法。
通过定义Runnable接口实现类，重写run方法，方法体为线程要完成的任务。创建实现类对象，通过该对象为参数创建Thread对象，该对象是线程对象。在通过线程对象调用 start方法启动线程。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类线程对象与线程任务绑定。
实现Runnable接口把线程对象与线程任务分离解耦。
实现Runnable接口优势：避免了继承的局限性，且实现了多线程共享资源。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题：
多线程执行任务与单线程执行时结果不同。
有3种方式解决线程安全问题。
1、同步代码块
2、同步方法
3、实现Lock接口，调用lock（）方法和unlock()方法
4.sleep()方法和wait()方法的区别？
sleep(参数)括号内为定时的时间毫秒值，时间到唤醒线程
wait()为无限等待，需要被其他线程唤醒用notify()方法等
5.线程有几种状态？他们之间是如何转化的？
6种状态
新建。未启动
可执行。
阻塞。当一个对象获取锁对象，其他试图获取锁对象的线程进入阻塞状态
计时等待。Thread.sleep或Object.wait方法，当超过设定时间，或被唤醒，终止等待，如获取了锁对象，则进入可执行状态，否在进入阻塞。
无限等待。一个线程进入Waiting状态，没有其他线程唤醒，无则处于等待状态。唤醒后如获取了锁对象，则进入可执行状态，否在进入阻塞。
终止 。run方法正常退出而死亡，或因没有捕获的异常终止了run方法而死亡。
作者: 练志成 时间: 2018-8-18 21:19
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 练志成 时间: 2018-8-18 21:20
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 张煜兴 时间: 2018-8-18 21:20
本帖最后由 张煜兴 于 2018-8-19 15:52 编辑
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种实现方式，一、继承方法：
（1）先创建继承了Thread的类，重写run方法，
（2）创建此类的对象，
（3）通过对象调用start方法开启新线程执行run方法
二、实现类Runnable的Thread类方法
（1）定义Runnable接口的实现类，重写run方法，
（2）创建该实现类的对象，作为Thread的构造函数参数创建Thread对象，
（3）用Thread对象调用start方法开启新线程执行run方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）解决了继承Thread类单继承的问题，实现多实现
（2）降低了继承Thread类的run方法设置任务和start方法开启新线程这两者间的耦合度（3）实现共享数据的前提
（4）线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
是因为JAVA是抢占式运行多线程的，当一个线程的执行任务还没结束时，就被其他线程抢走了，导致删除和更改操作的数据出现异常
有五种解决方法，一、同步代码块，二、同步方法，三、静态同步方法，四、lock、unlock方法，五、wait、notify方法
4.sleep()方法和wait()方法的区别？
sleep():计时等待，计时结束，继续执行代码
wait():无限等待，一直等到被notify解锁
5.线程有几种状态？他们之间是如何转化的？
6种状态，新建的线程，互相抢占资源，抢到资源的进入运行，没抢到的进入阻塞，被wait的进入无限等待，被sleep的进入计时等待，执行结束的被终止。
作者: 练志成 时间: 2018-8-18 21:20
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 练志成 时间: 2018-8-18 21:21
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 练志成 时间: 2018-8-18 21:21
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 练志成 时间: 2018-8-18 21:22
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 练志成 时间: 2018-8-18 21:23
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 李志超 时间: 2018-8-18 21:24
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无限等待/即使等待/锁阻塞/终止
如何转化请过来，我画图比较方便。
作者: 练志成 时间: 2018-8-18 21:24
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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 冰是睡着的水 时间: 2018-8-18 21:28
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时间到判断有没有取到锁。若有则执行，若无则到锁阻塞。
（黄嘉欣）
作者: 罗建辉 时间: 2018-8-18 21:28
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式:
继承Thread类:创建一个类继承与Thread接口,重写run方法
实现runnable接口:创建一个类实现runnable接口,重写run方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别在于继承Thread类只能是单继承,而实现接口可以多实现
优势:
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候会发生，数据不符合预期，数据错误。
解决方法:
将可能出现线程安全问题的代码用同步代码块包裹起来,一共有三种方法:同步代码块,同步方法,锁机制 (lock)
4.sleep()方法和wait()方法的区别？
sleep():使线程睡眠指定的时间,暂停任务,此时线程还持有锁
wait():使线程进入无限期睡眠,等待其他线程唤醒,此时线程释放锁,没有持有锁,被唤醒后,如果抢到锁进入runnable 状态,如果没前抢到则进入blocked状态
5.线程有几种状态？他们之间是如何转化的？
六种状态:
New新建状态
Blocked阻塞状态
Runnable运行状态
Waiting无限期等待状态
Timed waiting 计时等待状态
Teminated(终止状态)
线程刚被创建处于new状态,调用start()方法后进入运行状态,运行结束后进入终止状态.
若线程调用wait()方法,则进入无限期等待状态,等待 其他线程唤醒,唤醒后,如果抢到锁进入运行状态,如果没抢到则进入阻塞状态,等待下一次抢锁.
作者: 谢君昇 时间: 2018-8-18 21:29
1.多线程的实现有几种方式？实现步骤分别是怎样的？Thread：1、创建Thread的子类；2、重写run（）方法；3、创建子类对象；4、调用start（）方法；
runnable：1、创建runnable的实现类；2、重run（）方法；3、创建实现类对象，并把此对象作为Thread的target来创建Thread对象；4、调用start（）；
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1、避免了单继承的局限性；
2、增加了程序的拓展性，降低程序的耦合性；
3、共享数据的前提；
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程执行同一个线程任务时，每次运行的结果不能和单线程的结果一样，其他变量的值也和预想的不一样；
解决线程安全有三种方式：1、同步代码块；2、同步方法；3、Lock锁；
4.sleep()方法和wait()方法的区别？
sleep（）可以设置睡眠时间，不能主动释放锁；
wait（）除非被唤醒否则无限等待，可以主动释放锁；
5.线程有几种状态？他们之间是如何转化的？
6种：new，runnable，blocked，waiting，time-waiting，teminated；
作者: 黄艺纯 时间: 2018-8-18 21:30
1.多线程的实现有几种方式？实现步骤分别是怎样的？
四种。目前学了两种，分别为：
继承Thread类，重写run方法，创建子类对象，实例调用start（），开启新线程；
实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target，Threa的实例实例对象调用Start（），开启新线程。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：继承Thread类是多个线程分别完成自己的任务，实现Runnable是多个线程共同完成一个任务。
实现Runnable接口的优势：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。
4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程共享同一资源，同时对其进行改写、设置等操作。造成了异常数据，例如课程中的例子卖票造成的，一张票重复卖出，或者卖了第0、-1张票。
4.sleep()方法和wait()方法的区别？
sleep（）：相当于运行了一个方法，而方法体的运行时间为设置的参数，不会释放锁，时限到后，继续执行下列代码；
wait（）：是位于同步代码块里面的，调用该方法，就释放锁，处于计时等待或者无限等待，时限到了或者被其他线程notify（）唤醒，这是就加入到对锁的争抢当中，只有当抢到锁，才会进行运行状态，否则则为锁阻塞状态。
5.线程有几种状态？他们之间是如何转化的？
6种。
1.NEW(新建) 线程刚被创建，但是并未启动。
2.Runnable(可运行)
线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
3.Blocked(锁阻塞)
当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
4.Waiting(无限等待)
一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
5.Timed Waiting(计时等待)
同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
6.Teminated(被终止)
因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:31
1.Runnable接口,Thread类
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方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:31
1.Runnable接口,Thread类
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方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:33
1.Runnable接口,Thread类
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状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。被终止:因为run方法正常退出而死亡，或者因为没有捕获的异常终止了 run方法而死亡。
作者: liebstch 时间: 2018-8-18 21:33
陈建秋
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）线程任务运行完线程就被终止。
作者: 迪亚波罗 时间: 2018-8-18 21:34
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方法而死亡。
作者: 冰是睡着的水 时间: 2018-8-18 21:35
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时间到判断有没有取到锁。若有则执行，若无则到锁阻塞。
（黄嘉欣）
作者: 迪亚波罗 时间: 2018-8-18 21:35
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方法而死亡。
作者: weimengchao 时间: 2018-8-18 21:35
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()
作者: 迪亚波罗 时间: 2018-8-18 21:36
a'a'a'a'a'a'a'a'a'a'a'a'a'a'a
作者: 黄伟佳 时间: 2018-8-18 21:36
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种，互相转换- -。
作者: 黄晨伟 时间: 2018-8-18 21:36
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
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方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:37
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方法而死亡。
作者: 铜墙铁壁花无缺 时间: 2018-8-18 21:38
余金龙
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)：表示该线程已经执行完毕。
作者: 迪亚波罗 时间: 2018-8-18 21:39
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方法而死亡。
作者: 赖良峰 时间: 2018-8-18 21:41
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)：表示该线程已经执行完毕。 |
|
作者: 林胜强 时间: 2018-8-18 21:41
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方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:42
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方法而死亡。
作者: 陈锦祥 时间: 2018-8-18 21:42
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）线程任务运行完线程就被终止。
作者: 罗荣贵 时间: 2018-8-18 21:43
1.子类继承Thread类，子类重写run方法，子类对象调用start方法开启新线程
.实现类实现Runable接口 ，实现类重写run方法，创建Thread对象，将实现类对象作为传参传入，Thread对象调用start方法
2.Runnable接口 解耦，将线程任务和线程开启过程分离
突破继承的单继承的局限性，实现类可以继承多个接口
实现数据共享
3.共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候 会发生，数据不符合预期，数据错误。同步方法 静态同步方法 锁机制 加锁 和 释放锁
4.sleep方法是自定义暂停时间，时间过后会继续执行，锁不释放，wait方法是无限停止，只有当别的线程使用notify方法才能继续执行，停止过程中会释放锁
5.NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、WANTING（无限等待）、TERMINATE（终止）
作者: yangshixian 时间: 2018-8-18 21:43
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()方法时设定时间，转为计时等待状态
当线程执行完毕或抛出未捕获的异常或错误，转为被终止状态
杨式贤
六
作者: zouyitao 时间: 2018-8-18 21:44
邹毅涛
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终止
作者: 苏华琛 时间: 2018-8-18 21:44
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种状态
新建、运行、阻塞、等待、无线等待、终止
作者: 迪亚波罗 时间: 2018-8-18 21:44
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方法而死亡。
作者: 张子建 时间: 2018-8-18 21:45
1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread 重写run方法 创建子类的对象 子类调用start开启
接口Runnable 重写run方法 创建子类对象 子类对象传递给Thread参数 Thread对象调用start开启
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread是Runnable的实现类，Runnable可以资源共享，Thread比较局限性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程同时读取一个共享数据时会发生不可控的，结果不是预期结果
三种：同步代码块，同步方法，LOCK
4.sleep()方法和wait()方法的区别？
sleep()没有释放锁
wait（）释放锁
5.线程有几种状态？他们之间是如何转化的？
6种：new，runnable，blocked，waiting，time-waiting，teminated；
作者: 迪亚波罗 时间: 2018-8-18 21:46
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方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:47
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方法而死亡。
作者: 迪亚波罗 时间: 2018-8-18 21:48
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方法而死亡。
作者: 练志成 时间: 2018-8-18 21:48
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 迪亚波罗 时间: 2018-8-18 21:49
本帖最后由 迪亚波罗 于 2018-8-18 21:50 编辑
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 实现Runnable要创建Thread对象为线程对象，实现类对象为线程任务对象
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread在数据需要共享时不能用，实现Runnable提高代码灵活性。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程进行写操作时的结果与单线程不一致，产生线程问题。解决线程问题，使用同步代码块和同步方法和Lock锁
4.sleep()方法和wait()方法的区别？
sleep方法不释放锁，wait方法会释放锁
5.线程有几种状态？他们之间是如何转化的
NEW新建/RUNNABLE可运行/Blocked阻塞/WAITING无限等待/TimedWaiting即使等待/teminated终止
孙享
作者: 丶黑白 时间: 2018-8-18 21:50
余志斌
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种，一种通过继承。 创建Thread的子类重写run方法。new子类对象以此调用start方法。
一种通过实现。 创建Runnable的实现类重写run方法。new实现类对象，以此作为参数new Thread对象，通过Thread对象调用start方法。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
单继承、多实现。
避免单继承的局限性。可以实现线程任务和线程建立分离，降低耦合度，实现多线程任务共享。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
是在多个线程修改一个任务的数据时产生的。可以用安全代码块、安全方法、锁机制三种方式。
4.sleep()方法和wait()方法的区别？
sleep是该线程自身休眠，是有参、不释放锁的方法，条件满足自动苏醒。
wait是无限等待，需要其他线程唤醒。会释放锁。
5.线程有几种状态？他们之间是如何转化的
6种。 新建状态（刚new） ，通过start方法 进入run状态，以判断是否有锁判断是否进出locked状态。timewait ，执行该方法时从run进入，方法执行完毕退出至run。wait，执行该方法时从run进入，被唤醒时退出至run。 terminated，执行完毕时终止。
作者: 黄晨伟 时间: 2018-8-18 21:50
1.继承Thread类重写run方法 创建子类的对象 子类调用start开启
接口Runnable重写run方法 创建子类对象 子类对象传递给Thread参数 Thread对象调用start开启
2.一个是类一个是接口
3.线程安全问题是由于多线线程在对同一资源进行读写操作时，会发生与预期不相符的情况。
4.sleep（）可以设置睡眠时间，不能主动释放锁
调用wait()方法，线程属于Waiting状态，并会将锁释放掉
5.new，runnable，waiting,blocked，time-waiting，teminated六种
作者: 练志成 时间: 2018-8-18 21:50
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: MJ11 时间: 2018-8-18 21:52
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现由两种方式：1.继承Thread类 2.实现Runnable接口
1.（1）定义一个类继承Thread类
（2）重写run方法，将线程代码逻辑写到run方法中
（3）在测试类中创建子类对象，子类对象调用start()方法开启线程
2.（1）创建类实现Runnable接口，重写run方法将线程代码逻辑写到run方法
（2） 创建实现类对象（线程任务对象）
（3）创建线程对象 new Thread()
（4） 传递线程任务对象 new Thread()
（5） 调用线程对象(第4创建的)调用start方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口的优势体现在以下四个方面：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全：多个线程运行的结果和单线程程序运行的结果一致，结果是我们预期的结果
三种方式解决线程安全问题：1. 同步代码块。2.. 同步方法。3. 锁机制。
4.sleep()方法和wait()方法的区别？
Sleep()方法是计时等待，时间到了自动唤醒
wait()方法是无限等待，需要专门调用方法唤醒
5.线程有几种状态？他们之间是如何转化的？
线程有6种状态，分别是NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、WANTING（无限等待）、TERMINATE（终止）
田浪
作者: 练志成 时间: 2018-8-18 21:53
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 李伟javaee03 时间: 2018-8-18 21:53
1. 多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread类重写run方法，创建子类对象，子类对象调用start方法
实现Runnable接口，重写run方法，创建实现类对象，创建线程对象并传入实现类对象，线程对象调用start方法
2. 继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口可以由多个线程处理一件事情，继承Thread无法实现
避免了，Java的单继承的局限性， 实现了代码的解耦，可以将线程任务与线程对象进行分离，可以让多个线程对象执行同一个线程任务，让我们做一些共享数据的操作的前提条件
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
共享一个线程任务的时候，涉及到多个线程操作（写的操作）一个全局的或者静态的资源数据的时候会发生，数据不符合预期，数据错误。
同步代码块、同步方法、lock锁
4.sleep()方法和wait()方法的区别？
Sleep()方法在休眠时间后会进入运行状态，不会释放锁
Wait()方法是长期休眠，需要用notify()方法来唤醒，会释放锁
5.线程有几种状态？他们之间是如何转化的？
New（新建）线程刚被创建，但是并未启动
Runnable（运行）线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器
Bolcked（阻塞）当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态
Timedwaiting（计时等待）同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.waitWaiting（无限等待）一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
Teminated（终止）因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡
作者: 练志成 时间: 2018-8-18 21:54
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 林嘉志 时间: 2018-8-18 21:54
1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread 和 实现Runnable接口 都需要重写run方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
根据单继承多实现原理，继承Thread的类的线程的线程任务只能自己执行，不可以共享
实现Runnable接口，其实最后也需要new 新的线程来执行线程任务，但是可以共享，
优势；
1.适合多个相同的程序代码的线程共享一个资源
2.可以避免java中的单继承的局限性
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
4.线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程访问同一资源时，程序运行的结果可能和单线程运行的结果不同，也就是与预期不符
有三种方式解决：1. 同步代码块。 2. 同步方法。 3. 锁机制。
4.sleep()方法和wait()方法的区别？
sleep时计时等待，wait时时无限等待
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
5.线程有几种状态？他们之间是如何转化的？
六种
new创建线程
run可运行，多个线程竞争锁对象，当有一个线程a得到锁对象时，其余线程会进入Blocked锁阻塞，等待a执行完，如果a在执行资源时，调用wait方法那么会进入无限等待，那么会释放锁，其他的线程可以继续竞争锁对象，如果调用计时等待，要么等待时间到，并获取锁执行资源，要么时间到或时间未到但被唤醒，没有得到锁，进入锁阻塞，等待竞争。资源全部运行结束后被终止
作者: 练志成 时间: 2018-8-18 21:56
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 陈捷 时间: 2018-8-18 21:56
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.线程有几种状态？他们之间是如何转化的？
1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：当调用start方式时如果抢到锁就运行
3. 阻塞(BLOCKED)：如果没有抢到锁就等状态
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间后会自动唤醒。
6. 终止(TERMINATED)：表示该线程已经执行完毕。
作者: 仰望｀星空 时间: 2018-8-18 21:56
郭林源
1.多线程的实现有几种方式？实现步骤分别是怎样的？--->2种，第一种子类继承Thread类，重写run方法，然后创建子类对象，子类对象调用star方法开启新线程；第二种是实现runable接口，重写run方法，然后创建实现类线程任务，再新建Thread对象，传入线程任务，再用Thread对象调用star方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？--->java只能单继承多实现，所以用继承方法开启多个新线程时，须新建多个子类，实现Runnable接口则不用，并且实现Runnable接口还可以把设置线程任务和开启新线程进行了分离，降低耦合
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？--->线程安全是多个线程运行的结果与单个线程运行不一样，过程中可能常量会被修改和写入。解决办法，第一种同步机制synchronized，第二种LUCK锁
4.sleep()方法和wait()方法的区别？--->sleep是进入休眠状态，但休眠后程序还在执行。wait是休眠后结束程序
5.线程有几种状态？他们之间是如何转化的？--->6种状态，new--新建程序时启动，run--线程对象调用star方法后，并且线程抢到同步锁对象后进入run，没抢到的线程进入阻塞，等进入run的方法执行结束后，重新抢同步锁对象，调用wait方法后，进入无限等待阶段，等另一个线程调用notify方法后，激活进入无限等待的线程，用sleep或wait方法后进入计时等待阶段，sleep休眠时间结束后，线程继续进行，wait是休眠时间结束后，结束线程
作者: 郑颖锋 时间: 2018-8-18 21:57
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式：
1.创建子类继承Thread类，重写run方法，通过子类对象调用.start()启用新线程；
2.通过子实现类实现Runnable接口，通过Runnable接口的实现类对象作为Thread的target来创建Thread对象。
通过Thread对象调用start()方法启动新线程。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1.实现Runnable接口避免了单继承的局限性 。类继承了Thread类就不能再继承其他类，实现Runnable接口还可以继承其他类，实现其他接口。
2.增强了程序的扩展性,降低了程序的耦合性(解耦)。 实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
实现线程安全问题的方法有三种：
1.使用同步代码块
2.使用同步方法
3.lock锁机制
4.sleep()方法和wait()方法的区别？
sleep（）可以设置睡眠时间，不能主动释放锁；
wait（）除非被唤醒否则无限等待，可以主动释放锁；
5.线程有几种状态？他们之间是如何转化的？
六种状态：
NEW(新建)、Runnable(可运行)、Blocked(锁阻塞)、Waiting(无限等待)、TimedWaiting(计时等待)、Teminated(被终止)
(1)新建一个线程对象处于可运行状态，如果它抢到了锁对象，就可以运行，如果没抢到就会进入阻塞状态，
(2)当线程抢到锁，通过sleep方法进入TimedWaiting状态，sleep时间结束后进入可运行状态，如果是Wait方法结束那么就需要重新去抢锁，如果抢到就进入可运行状态
没抢到就进入阻塞状态。
（3）当线程抢到锁，通过wait()方法进入无线等待状态，如果被其他线程就需要等待其他线程的唤醒，当其他线程唤醒它时，就需要去抢夺锁，抢到就运行，没抢到进入阻塞
状态。
（4）线程任务运行完线程就被终止。
作者: 练志成 时间: 2018-8-18 21:57
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 刘建宝 时间: 2018-8-18 21:58
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方法
终止状态：所有线程停止
作者: 练志成 时间: 2018-8-18 21:58
//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方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: shenxiaogan 时间: 2018-8-18 21:59
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无限等待/即使等待/锁阻塞/终止
作者: 小鱼七 时间: 2018-8-18 21:59
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状态，没有其他线程唤醒，无则处于等待状态。唤醒后如获取了锁对象，则进入可执行状态，否在进入阻塞。，被终止 |
|
作者: 吴鑫佳 时间: 2018-8-18 21:59
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
作者: 张剑猛 时间: 2018-8-18 22:00
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
作者: spik 时间: 2018-8-18 22:00
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
作者: 小悦悦 时间: 2018-8-18 22:00
有两种方式：一种方式是声明为声明为Thread，一种方式是声明一个类实现Runnable 接口
2.Runnable接口 解耦，将线程任务和线程开启过程分离
突破继承的单继承的局限性，实现类可以继承多个接口
实现数据共享
3.共享一个线程任务的时候，涉及到多个线程操作（修改、写的操作）一个全局的或者静态的资源数据的时候 会发生，数据不符合预期，数据错误。同步方法 静态同步方法 锁机制 加锁 和 释放锁
4.sleep方法是自定义暂停时间，时间过后会继续执行，锁不释放，wait方法是无限停止，只有当别的线程使用notify方法才能继续执行，停止过程中会释放锁
5.NEW（新建）、RUNNABLE（运行）、BOLCKED（阻塞）、TIMED-WAITING（计时等待）、WANTING（无限等待）、TERMINATE（终止）
--李翔
作者: ZNBran 时间: 2018-8-18 22:00
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终止
================================================ 周楠
作者: 舟sir 时间: 2018-8-18 22:03
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 已退出的线程处于这种状态。
周家乾
作者: 赵烈刚 时间: 2018-8-18 22:09
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（终止）。
作者: Michcale 时间: 2018-8-19 10:41
------------------吴齐宾-------------------------
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种状态,开始,运行,停止,阻塞,睡眠等待,无线等待
作者: 林靖 时间: 2018-8-19 10:55
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.线程有几种状态？他们之间是如何转化的？
新建
可运行
阻塞
无限等待
记时等待
终止
作者: 陈张辉 时间: 2018-8-20 19:05
1.多线程的实现有几种方式？实现步骤分别是怎样的？
三种
1，实现线程类接口，重写run方法，创建实现类对象，创建线程接口子类对象并且把实现类对象赋值其中，最后调用start
2.创建接口子类继承类，重写run方法，创建继承类对象，调用start方法
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
是因为JAVA是抢占式运行多线程的，当一个线程的执行任务还没结束时，就被其他线程抢走了，导致删除和更改操作的数据出现异常
有五种解决方法，一、同步代码块，二、同步方法，三、静态同步方法，四、lock、unlock方法，五、wait、notify方法
4.sleep()方法和wait()方法的区别？
wait是让线程进入永久睡眠状态，sleep是进入读秒停止状态
5.线程有几种状态？他们之间是如何转化的？
六种，开始-->运行--（如果使用sleep方法-->进入读秒暂停状态/--如果使用wait方法-->进入永久睡眠状态/--如果遇到同步代码块-->拿到钥匙-->进入运行状态/--没有拿到钥匙-->进入堵塞状态）-->程序结束
作者: 沈智桂 时间: 2018-8-20 19:27
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方法会进入睡眠等待状态，没有释放锁，当时间到了如果有锁对象进入可运行状态，运行状态结束进入销毁状态
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |