黑马程序员技术交流社区

标题: 【厦门JavaEE就业6期-每日总结】线程、同步 [打印本页]

---

作者: 厦门校区    时间: 2019-3-26 14:48
标题: 【厦门JavaEE就业6期-每日总结】线程、同步
1.多线程的实现有几种方式？实现步骤分别是怎样的？
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？

---

作者: 黑马六期-董安平    时间: 2019-3-26 21:21
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
有两种实现方式，一种是继承Thread类，一种是实现Runnable接口。
（1）.继承Thread类
定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

（2）.实现Runnable接口：
定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正 的线程对象。
调用线程对象的start()方法来启动线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
区别在于，继承Thread类不适合进行资源共享，而实现Runnable接口则更适合实现资源共享。
优势在于：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。 4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
线程安全问题是由全局变量及静态变量引起的，如果多个线程对全局变量及静态变量进行写操作，就会发生线程安全问题。
解决线程安全问题有以下方法：
1. 同步代码块。
2. 同步方法。
3. 锁机制。
4.sleep()方法和wait()方法的区别？
答：
1.wait方法是来源于Object类的方法，sleep是来源与Thread方法


2.wait方法调用后，会释放锁对象和CPU执行权，sleep方法调用后，只会释放CPU执行权，不会释放锁对象

---

作者: 郑海波    时间: 2019-3-26 21:38
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现由三种方式
1.继承Thread
步骤：1.创建一个子类继承Thread类
      2.在这个子类重写run方法
      3.在main函数里创建子类对象
      4.通过start方法开启新线程，运行run方法
2.实现Runnable接口
步骤：1.创建一个Runnable接口的实现类
      2.在该实现类重写run方法
      3.在main函数里创建实现类对象
      4.创建Thread对象调用start方法开启新线程，运行run方法
3.匿名内部类
步骤：1.在main函数里新建一个Thread或者Runnable
      2.重写这个匿名内部类的run方法
      3.通过start方法开启新线程，运行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
使用继承Thread类的方式重写的run方法无法被重复利用，耦合度太高（既具有创建对象的功能，又有线程任务的功能），且该方式会占用一个继承位；实现Runnable接口的方式只具有线程任务的功能，耦合度低，且重写的run方法能重复使用，可以继承其他类或者多个接口。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
如果有多个线程同时操作同一个资源，并对这个资源中的数据进行修改时，会产生线程安全问题。
解决线程安全问题的方式：
1.同步代码块
使用格式：synchronized（同步锁）{进行同步操作的代码}
2.同步方法
在Runnable实现类里定义一个使用synchronized修饰的方法
使用格式：修饰符 synchronized 返回值类型 方法名（参数列表）{进行同步操作的代码}
3.Lock锁
在Runnable实现类里新建一个ReentrantLock()对象，调用lock和unlock方法加同步锁和释放同步锁
使用格式执行同步操作代码前加同步锁方法，结束后执行释放同步锁方法

4.sleep()方法和wait()方法的区别？
区别：
1.来源：sleep是object类的方法
        wait是thread类的方法
2.释放对象：sleep方法使用后只能释放cpu执行权
            wait方法同时释放锁对象和cpu执行权

---

作者: omasoo    时间: 2019-3-26 21:39
李伟斌

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答:继承Thread和实现Runnable接口两种。
   Thread的实现步骤：a.继承Thread类  b.重写run方法  c.创建子类对象  d.子类对象.start方法
   Runnable接口的实现步骤：a.实现Runnable接口  b.重写run方法  c.创建子类对象 d.创建Thread对象，new Thread（子类对象）  e.使用start方法开启线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：实现Runnable接口比继承Thread类所具有的优势：
    a.适合多个相同的程序代码的线程去共享同一个资源。
    b.可以避免java中的单继承的局限性。
    c.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
    d.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：多个线程在抢CPU时，抢到CPU的线程代码还没执行完，CPU又跑去执行另外一条线程，造成数据重复以及不存在的数据产生。
    当线程抢到资源要执行时，需要用锁锁住，让线程执行完再释放锁。
    有同步代码块，同步方法，和lock锁三种方式解决。
4.sleep()方法和wait()方法的区别？
答：sleep（）方法属于Thread类，会自动唤醒自己，代码执行完时不释放锁。
    wait（）方法属于Object类，需要notify方法进行唤醒，代码执行完后会释放锁。

---

作者: 陈驰煜    时间: 2019-3-26 21:39
1.多线程的实现有几种方式？实现步骤分别是怎样的？
有2种;
a.使用子类继承Thread类,重写run方法,创建子类对象,使用子类对象名调用start方法
b.实现Runnable接口,重写run方法,创建Thread类对象,参数为Runnable的实现类对象或匿名内部类,通过Thread类对象调用start方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread类只能继承,需要占用子类的继承位,且子类的功能和多线程混在一起,代码耦合度较高;
实现Runnable接口比继承Thread类所具有的优势：


1. 适合多个相同的程序代码的线程去共享同一个资源。

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

3. 增加程序的健壮性，实现解耦操作(将设置线程的任务和开启新线程分离)，代码可以被多个线程共享，代码和线程独立。

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




3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程都对共享的资源进行修改操作时,可能出现线程安全问题;
解决方式:
1.同步代码块
synchronized(同步锁){
    可能产生线程安全问题的代码
}
2.同步方法
public synchronized void 方法名(){可能产生线程安全问题的代码}

3.Lock锁
在成员变量位置定义
Lock lock = new ReentrantLock;

lock.lock();


可能产生线程安全问题的代码


lock.unlock();


4.sleep()方法和wait()方法的区别？
1.sleep方法是Thread类中的方法,wait是Object类中的方法
2.sleep方法等待时只释放cpu,wait方法会同时释放cpu和锁

---

作者: 陈志铖    时间: 2019-3-26 21:39
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式 创建继承Thread的子类      new Thread(借口Runnable的实现类)
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
避免了单继承的局限性
增强了程序的扩展性,降低了程序的耦合性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
sleep并没有释放锁对象

---

作者: zhaizhile    时间: 2019-3-26 21:39
1.多线程的实现有几种方式？实现步骤分别是怎样的？
第一种:继承Thread
步骤如下：
    1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
    2. 创建Thread子类的实例，即创建了线程对象
    3. 调用线程对象的start()方法来启动该线程
第二种:实现Runnable接口
步骤如下：
   1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
   2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。
   3. 调用线程对象的start()方法来启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
    如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

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

3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
    当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题
解决方式:
    1,同步代码块: synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
    2,同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着
    3,Lock锁:java.util.concurrent.locks.Lock 机制提供了比synchronized代码块synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
4.sleep()方法和wait()方法的区别？
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待

---

作者: 陈伟彬    时间: 2019-3-26 21:39


1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
        三种；
        继承Thread类：
                创建一个继承Thread类的子类；
                在子类里重写Thread类里面的run方法，设置线程任务；
                在测试类里创建这个子类的对象；
                调用start方法开启新线程，运行重写后的run方法；
        实现Runnable接口：
                创建一个Runnable接口的实现类；
                在这个实现类里重写run方法，设置线程任务；
                在测试类里创建这个实现类的对象；
                创建Thread类对象来调用start方法开启新线程，运行重写的run方法；
        匿名：
                直接在测试类new一个Thread类或Runnable接口
                然后重写里面的run方法，设置线程任务；
                调用start方法开启新线程，运行重写后的run方法；
                如果是直接new Runnable接口，还需要创建一个Thread类对象来调用start方法；
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
        区别与优势：
                耦合度：
                        继承Thread类的既具有创建对象的功能，又有线程任务的功能，耦合度高；
                        实现Runnable接口的只有线程任务的功能，耦合度低；
                局限性：
                        继承Thread类的只能有一个子类，直接创建子类会占用继承位，局限性高；
                        实现Runnable接口的可以可以有多个实现类，不会占位，局限性低；
                资源共享：
                        继承Thread类的资源和线程对象是合在一起的，无法共享同一资源；
                        实现Runnable接口的资源和线程对象分离，则实现了资源共享；
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
        线程安全问题：多个 线程操作同一个资源，在对资源的数据执行修改操作的时候，此时有可能会发生线程安全问题；
        解决方案：进行线程同步，让可能会出现问题的代码，只能有一个线程在里面运行；
        方式：；
                同步代码块：synchronize(锁对象){可能出现线程安全问题的代码}；
                同步方法：public synchronize 返回值类型 方法名(){可能出现线程安全问题的代码}；
                        静态同步方法：public start synchronize 返回值类型 方法名(){可能出现线程安全问题的代码}；
                Lock锁：先创建一个Reentrantlock对象；然后在问题代码前获取锁(void lock())；最后在问题代码后释放锁（void unlock（））；
4.sleep()方法和wait()方法的区别？
答：
        区别：
                来源：
                        sleep方法是来源于Thead类的方法；
                        wait方法是来源于Object类的方法；
                释放对象：
                        sleep方法调用后，只会释放CPU执行权，不会释放锁对象；
                        wait方法调用后，会释放锁对象和CPU执行权；

---

作者: 李煜霖    时间: 2019-3-26 21:40
1.多线程的实现有几种方式？实现步骤分别是怎样的？

多线程的实现有两种方式。
第一种步骤：
①定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就是该线程的执行体。
②创建Thread子类的实例，就是创建线程对象
③调用线程对象的start()方法来开启线程

第二种步骤：
①定义Runnable接口的实现类，并重写该接口的run()方法。该run()方法就是该线程的执行体。
②创建Runnable接口的实现类实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
③调用线程对象的start()方法来开启线程

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

继承Thread类和实现Runnable接口的区别是：
继承Thread类：不适合资源的共享
实现Runnable接口：很容易实现资源共享

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

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

线程安全问题的产生原因：
当多个线程去操作同一个资源，并对资源中的数据实行修改操作，就会出现线程安全问题

解决线程安全问题有三种方式
①同步代码块
②同步方法
③Lock锁

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

sleep()方法：sleep()方法来源于Thread类，没有获取锁和释放锁的过程，sleep()方法必须给定一段休眠时间，休眠时间一到线程开始活动
wait()方法：wait()方法来源于Object类，有获取锁和释放锁的功能，wait()方法可以不给定休眠时间，如果没有给定休眠时间，
线程将永久睡眠，直到调用Object类中的notify()方法才能唤醒，继续活动

---

作者: 罗加铭    时间: 2019-3-26 21:40
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种分别是继承Thread类来创建和定义Runnable接口的实现类；
Thread类：1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。2. 创建Thread子类的实例，即创建了线程对象3. 调用线程对象的start()方法来启动该线程
Runnable接口：1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。3. 调用线程对象的start()方法来启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
三种方式解决：同步代码块，synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问；同步方法，使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着；Lock锁,lock()加同步锁unlock() :释放同步锁

4.sleep()方法和wait()方法的区别？
答：sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

---

作者: java基础6期刘伟    时间: 2019-3-26 21:40
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种，一种是继承Thread。（1） 定义Thread类的子类，并重写该类的run()方法，
该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。
（2） 创建Thread子类的实例，即创建了线程对象
（3） 调用线程对象的start()方法来启动该线程

一种是接口Runnable。（1） 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
（2） 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正 的线程对象。
（3） 调用线程对象的start()方法来启动线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
优势：适合多个相同的程序代码的线程去共享一个资源；可以避免JAVA中的单继承局限性；
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立；
线程池只能放入实现Runnable或者Callable类线程，不能直接放入继承Thread的类。

3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题都是由全局变量以及静态变量引起的，若每个线程中对全局变量，静态变量只有读操作，而无写操作，
一般来说，这个全局变量是线程安全的 ；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。
有三种方式：同步代码块，同步方法，Lock锁，同步代码块用的最多。

4.sleep()方法和wait()方法的区别？
sleep（）是Thread里的方法，wait（）是Object里的方法；
sleep（）执行，释放CPU不释放同步锁锁， wait（）执行释放CPU和同步锁锁。

---

作者: 叶振鹏    时间: 2019-3-26 21:40
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
二种方式：
一、继承Thread类的方式实现（1）创建一个类让这个类extends Thread
                          （2）覆盖重写Thread类中的run（）方法，创建线程任务
                          （3）在测试类中创建子类的对象
                          （4）子类对象调用父类中的start（）方法  
二、实现Runnable接口（1）创建一个类让这个类implements Runnable
                    （2）覆盖重写Runnable类中的run（）方法，创建线程任务
                    （3）在测试类中创建实现类的对象
                    （4）创建Thread类的对象
                    （5）将实现类对象作为参数传递至Thread类的构造方法中
                    （6）调用Thread类中的start（）方法


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
继承Thread类和实现Runnable接口的区别：每个类只能有一个直接父类，可以实现多个接口，使用继承的方式，那么这个类就不能继承其他的类
实现Runnable接口的优势： 1.避免了单继承的局限性
                              一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
                                实现了Runnable接口,还可以继承其他的类,实现其他的接口
                         2.增强了程序的扩展性,降低了程序的耦合性(解耦)
                               实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
线程安全问题是多个线程共享同一个资源，并对这个资源的数据进行修改操作
有三种方式解决线程安全问题：
一、同步代码块，格式
     创建安全锁对象  Object obj = new Object（）；
        synchronize（obj）{
            可能出现线程安全的代码
     }
二、使用同步方法，格式
    修饰符  synchronize 返回值 方法名（参数列表）{
              
               可能出现线程安全的代码
              
   }
三、Lock（接口）锁，使用步骤:
    1.在成员位置创建一个ReentrantLock对象
    2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
    3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

4.sleep()方法和wait()方法的区别？
答：
1.两个方法的来源不一样sleep方法来源于Thread类wait方法来自Object

2.wait方法调用后会释放锁对象和CPU执行权；sleep方法只释放CPU执行权

---

作者: 管文祥    时间: 2019-3-26 21:41
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：有两种实现多线程的方式：
（1）继承Thread类，实现Thread类的run方法。随后在调用处建立子类的对象，并用子类的对象调用start方法，建立一条线程；
（2）实现Runnable接口，实现Runnable接口的run方法。随后在调用处建立实现类的对象，将对象传入Thread的有参构造方法中，建立Thread的子类对象，并通过其调用start方法，建立一条线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类只需要建立子类的对象，就可以调用start方法，建立线程。而实现Runnable的接口需要先建立实现类的对象，然后再将其作为参数传入Thread的有参构造方法中，建立Thread类的子类对象，借助Thread的子类对象调用start方法，建立线程。
优势：因为继承属于单继承，也就是说继承了Thread类后，该子类不能继承其他的类，而实现Runnable接口后，该类还可以继承其他的类，实现其他的接口。除此之外，实现Runnable接口可以实现资源共享。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：当多个线程共享一份数据资源时，并试图对该数据进行修改操作时很容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。解决线程安全问题一般有三种方式：
（1）同步代码块，synchronized 关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式：synchronized(同步锁){需要同步操作的代码}，多个线程必须使用同一把同步锁。
（2）同步方法，即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：public synchronized void method(){可能会产生线程安全问题的代码}。
（3）Lock锁，也称同步锁，将加锁与释放锁方法化了，用lock()方法加同步锁，用unlock()方法释放同步锁，在这两个方法之间的代码对线程具有排他性，即同一时间只允许一个线程执行该段代码。

4.sleep()方法和wait()方法的区别？
答：（1）wait方法是来源于Object类的方法，sleep是来源于Thread类的方法。
（2）wait方法调用之后，会释放锁对象和CPU的执行权；sleep方法不释放锁对象，只释放CPU执行权。

---

作者: 钟扬辉    时间: 2019-3-26 21:41
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种
（1）继承Thread类
        1.子类继承Thread类
         2.重写Thread类的run方法
        3.在测试类中创建子类对象
        4.条用start方法开启线程
（2）实现Rannable接口
        1.实现类实现Runnable接口
        2.重写接口中的run方法
        3.在测试类中创建线程对象Thread，将实现类作为参数传递出去
        4.调用start方法开启线程       
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：如果一个类继承Thread，则不适合资源共享，但如果实现了Runnable接口的话，则很容易实现资源共享
优势：1.适合多个相同的程序代码的线程去共享同一个资源
           2.可以避免java中的单继承局限性
          3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
          4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
  线程安全问题：
      (1) 线程修改数据，会产生重复的数据
    （2）线程会产生不存在的数据
  解决方式：
       1.同步代码块  synchronized(同步锁){需要同步操作的代码}  注意事项：同步代码块的锁对象可以是任意对象，但必须保证多个线程的锁对象是一个。
        2.同步方法  public synchronized void meth(){可能会产生线程安全问题的代码}     锁的对象是this
        3.静态的同步方法   public static synchronized void method(){可能会产生线程问题的代码}    锁的对象是类名 .class
4.sleep()方法和wait()方法的区别？
Sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动苏醒。sleep方法
进入到睡眠不会释放锁对象。
wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤醒。wait方法
会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权。

---

作者: 罗加铭    时间: 2019-3-26 21:41
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种分别是继承Thread类来创建和定义Runnable接口的实现类；
Thread类：1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。2. 创建Thread子类的实例，即创建了线程对象3. 调用线程对象的start()方法来启动该线程
Runnable接口：1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。3. 调用线程对象的start()方法来启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
三种方式解决：同步代码块，synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问；同步方法，使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着；Lock锁,lock()加同步锁unlock() :释放同步锁

4.sleep()方法和wait()方法的区别？
答：sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

---

作者: 徐代成    时间: 2019-3-26 21:41
1.多线程的实现有几种方式？实现步骤分别是怎样的？

两种
（1）继承Thread类  
<1>首先新建一个继承类继承Thread类
<2>在继承类中重写Thread类中的run方法，在run方法中写任务模块
<3>创建继承类对象
<4>用继承类对象调用start方法来开启线程

（2）实现Runnable接口
<1>首先新建一个接口实现类
<2>重写Runnable接口的run方法，在run方法中写任务模块
<3>创建接口实现类对象
<4>创建Thread对象，传入接口实现类对象作为参数
<5>用Thread对象调用start方法开启线程

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

<1>继承Thread类占用了继承位，无法实现其他继承关系；而Runnable接口是实现类，不影响继承。
<2>继承Thread类子类既需要穿件对象，又有线程任务，耦合度太高；而Runnable接口只是实现线程的任务功能，
<3>继承Thread类多个对象无法共享资源；而Runnable接口可以创建多个对象是，实现资源共享。
所以，Runnable接口避免了单继承性的局限性，又降低了耦合度

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

线程的安全是在多个线程同时访问修改共享资源的时候产生的
我们可以通过提取共享模块，然后给共享模块加锁来限制访问线程的数量，从而解决线程安全问题。
主要有三中方式：
<1>在共享模块前加上synchronize关键字；
<2>提取共享模块，将模块放在方法中，在方法上加synchronize关键字；
<3>Lock接口实现类ReentrantLock，通过实现类对象调用lock方法加锁，unlock释放锁。

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

<1>sleep方法时Thread类中；wait是Object类中的方法。
<2>sleep方法在执行时是释放CPU执行权，不会释放锁对象；wait方法执行是，不仅会释放CPU执行权，还会释放锁对象。

---

作者: 余建强    时间: 2019-3-26 21:41
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式,一种是通过继承,另一种是通过接口实现
继承:创建一个子类,继承Thread,重写父类中的run()方法,创建对象,开启线程
接口:创建一个接口实现类,实现Runnable接口,重写run()方法,创建对象,
再创建Thread将创建的对象传入Thread中,开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承:创建的每一个线程都是一个崭新的线程
实现:一个线程对象可以多次被开启
实现的优势:同一个线程可以多次被开启,一个子类只能继承一个父类,继承Thread会占用继承父类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题时怎么产生的:同一块代码区域被多条线程进行改写造成的线程安全问题;
如何解决线程安全问题:通过加synchronized来解决线程安全问题;有三种方式解决;
1)同步代码块
2)同步方法
3)锁机制

4.sleep()方法和wait()方法的区别？
sleep()属于Thread,wait()属于Object,sleep()休眠期间不会归还锁,wait()休眠期间会归还锁

---

作者: javawjs    时间: 2019-3-26 21:42
王佳盛
1.        多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式：
第一种方式：继承Thread类
（1）        自定义一个Thread的子类
（2）        重写run（）方法
（3）        测试类中创建Thread子类对象，调用start（）方法开启新线程
第二种方式：实现Runnable接口
（1）        创建Runnable的实现类
（2）        测试类中创建Runnable的实现类对象
（3）        创建Thread对象，调用带参构造方法传入Runnable实现类对象作为参数
（4）        调用start（）方法开启新线程

2.        继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类：占用了继承位；在Thread之类中重写run（）方法，不能够实现多个线程执行同一段代码。耦合度太高。
实现Runnable接口：实现了Runnable接口还能继承其它类，在Runnable实现类重写run（）方法，通过构造方法传入Runnable实现类对象作为参数创建Thread类对象调用start（）方法开启新线程，可以实现多个线程执行同一段代码，降低了耦合度。
优势：
（1）        避免了单继承的局限性
（2）        增强了程序的扩展性，降低了程序的耦合性
（3）        实现了Runnable接口的方式，将线程任务和开启新线程进行了分离。

3.        线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当我们要用多个线程对共享数据进行修改的时候，由于CPU的是高速在多个线程之间切换执行的，所以在修改共享数据的时候就有可能出现问题（例如：卖票案例中，出现了一张票被卖了多次等）
解决方案：
第一种方式：同步代码块
        将可能会出现线程安全问题的代码抽取到synchronize代码块中
        格式 ： synchronize（锁对象）{可能会出现问题的代码}
第二种方式：同步方法
        把访问了共享数据的代码抽取到一个方法中，并用synchronize修饰该方法
        格式：修饰符 synchronize 返回值类型 方法名（参数列表）{ 方法体 }
第三种方式：Lock锁
（1）        在成员位置创建一个ReentrantLock对象
（2）        在可能出现安全问题的代码前调用Lock接口中的lock（）方法获取锁
（3）        在可能出现安全问题的代码后调用Lock接口中的unlock（）方法释放锁

4.sleep()方法和wait()方法的区别？
sleep（）：线程失去CPU执行权，但仍然拥有锁对象。只有当线程执行完成同步代码，才会释放锁对象
wait（）：线程失去CPU执行权，并立即释放锁对象。若方法中没有传入参数，则线程进入无限等待状态。等待被notify（）唤醒。若方法中传入参数x,则方法在等待x毫秒后被唤醒重新进入阻塞状态，等待争抢CPU执行权

---

作者: 王旭艺    时间: 2019-3-26 21:42
1.多线程的实现有几种方式？实现步骤分别是怎样的？
    (1)一种是继承Thread类方式
    步骤是:
    a. 创建一个Thread类的子类
    b. 在Thread类的子类中重写Thread类中的run方法,设置线程任务
    c. 创建Thread类的子类对象
    d. 调用Thread类中的方法start方法,开启新的线程,执行run方法

   (2)一种是实现Runnable接口方式
   步骤：
    a. 创建一个Runnable接口的实现类
    b. 在实现类中重写Runnable接口的run方法,设置线程任务
    c. 创建一个Runnable接口的实现类对象
    d. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    e. 调用Thread类中的start方法,开启新的线程执行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
     如果一个类继承Thread，则不适合资源 共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
     实现Runnable接口比继承Thread类所具有的优势：
(1) 适合多个相同的程序代码的线程去共享同一个资源。
(2) 可以避免java中的单继承的局限性。
(3) 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
(4）线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
前提：多个线程在执行同一资源并对资源进行数据的修改
产生的安全问题：a.线程修改数据，会产生重复的数据;b.线程会产生不存在的数据
解决方式：a.同步代码块
          b.同步方法
          c.Lock锁

4.sleep()方法和wait()方法的区别？
    sleep()方法使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
     wait()方法，无限期等待另一个线程执行一个特别的（唤醒）动作的线程
     sleep()方法源于Thread类让线程进入睡眠，指定了睡眠时间，时间一到自动苏醒。它进入到睡眠不会释放对象。
      wait()方法源于Object类，让线程进入等待，指定等待时间或者不指定知道其他线程唤醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

---

作者: 管文祥    时间: 2019-3-26 21:43
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：有两种实现多线程的方式：
（1）继承Thread类，实现Thread类的run方法。随后在调用处建立子类的对象，并用子类的对象调用start方法，建立一条线程；
（2）实现Runnable接口，实现Runnable接口的run方法。随后在调用处建立实现类的对象，将对象传入Thread的有参构造方法中，建立Thread的子类对象，并通过其调用start方法，建立一条线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类只需要建立子类的对象，就可以调用start方法，建立线程。而实现Runnable的接口需要先建立实现类的对象，然后再将其作为参数传入Thread的有参构造方法中，建立Thread类的子类对象，借助Thread的子类对象调用start方法，建立线程。
优势：因为继承属于单继承，也就是说继承了Thread类后，该子类不能继承其他的类，而实现Runnable接口后，该类还可以继承其他的类，实现其他的接口。除此之外，实现Runnable接口可以实现资源共享。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：当多个线程共享一份数据资源时，并试图对该数据进行修改操作时很容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。解决线程安全问题一般有三种方式：
（1）同步代码块，synchronized 关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式：synchronized(同步锁){需要同步操作的代码}，多个线程必须使用同一把同步锁。
（2）同步方法，即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：public synchronized void method(){可能会产生线程安全问题的代码}。
（3）Lock锁，也称同步锁，将加锁与释放锁方法化了，用lock()方法加同步锁，用unlock()方法释放同步锁，在这两个方法之间的代码对线程具有排他性，即同一时间只允许一个线程执行该段代码。

4.sleep()方法和wait()方法的区别？
答：（1）wait方法是来源于Object类的方法，sleep是来源于Thread类的方法。
（2）wait方法调用之后，会释放锁对象和CPU的执行权；sleep方法不释放锁对象，只释放CPU执行权。

---

作者: 黄杰南    时间: 2019-3-26 21:43
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式。一种是通过创建子类继承Thread，重写run方法，创建子类对象，调用start方法。另一种是通过实现runnable接口，重写run方法，创建实现类对象，创建Thread对象，把接口实现类对象作为Thread的构造参数传递进去，再通过Thread对象来调用start方法，开启新线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1.继承的特点是单继承，而实现的特点是多实现。因此，继承Thread就无法继承其他类，而实现runable接口还能去实现其他接口，去继承类；
2.继承Thread类，创建子类对象后，开启线程和运行线程任务是绑定在一起的，耦合度太高，不利于后期修改，以及线程任务的共享；而实现runable接口则接口的实现类中设置线程任务，开启线程通过创建Thread对象，则两者是分开的，降低耦合度，增强了程序的拓展性。
优势：耦合性低，线程任务和线程对象分开；可以反复使用线程任务，实现资源共享。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多条线程共用资源且执行写操作时就会发生线程安全问题。
用同步代码块（synchronized关键字）；用同步方法；用lock锁（lock和unlock方法）

4.sleep()方法和wait()方法的区别？
sleep是Thread类中的方法；不释放同步锁；时间到，自动唤醒
wait是object的方法；释放同步锁；需要notify方法来唤醒，否则就一直无限等待。

---

作者: 廖艺铭    时间: 2019-3-26 21:43
1.多线程的实现有几种方式？实现步骤分别是怎样的？

多线程的实现有两种方式：

第一种：继承Thread类

①继承Thread类，重写该类的run()方法，run()方法写的是线程所要完成的任务

②测试类中创建Thread子类的实例对象，也就是创建线程对象

③调用该线程对象的start()方法来启动该线程

第二种：实现Runnable接口

①创建Runnable接口的实现类，重写Runnable接口的run()方法，设置线程任务

②创建Runnable接口的实现类对象，并将该对象作为Thread的target来创建Thread对象

③调用Thread对象的start()方法，开启新线程

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

继承Thread类和实现Runnable接口的区别：

①继承Thread类将设置线程任务和开启新线程合在一起，代码耦合度较高，而且不适合数据共享

②实现Runnable接口把设置线程任务和开启新线程进行分离，降低耦合度，且适合资源共享

实现Runnable接口比继承Thread类所具有的优势：

①避免了Java单继承的局限性，一个类继承了Thread类就不能继承其它类，而实现Runnable接口还可以实现其它的接口，继承其它类

②实现Runnable接口的方式，把重写run()方法设置线程任务和调用start()方法开启新线程进行了分离，降低了代码耦合度，增强了程序的健壮性

③适合多个相同的程序代码的线程去共享同一个资源

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

线程安全问题产生原因：

当程序中有多个线程访问共享数据时，且多个线程中对该数据有写操作时，容易出现线程安全问题

解决线程安全问题有三种方式：

第一种：同步代码块

使用 synchronized 关键字，用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

格式:

synchronized(同步锁){

        需要同步操作的代码

}

其中，同步锁的作用是把同步代码块锁住,只让一个线程在同步代码块中执行，可以是可以使用任意的对象，但是必须保证多个线程使用的锁对象是同一个

第二种：同步方法

把访问了共享数据的代码抽取出来，放到一个方法中，在方法上添加synchronized修饰符

格式:

修饰符 synchronized 返回值类型 方法名(参数列表){

        可能会出现线程安全问题的代码(访问了共享数据的代码)

}

同步方法的锁对象是this，静态同步方法的锁对象是方法所在类的字节码对象(类名.class)

第三种：Lock锁

a.在成员位置创建一个ReentrantLock对象

b.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁

c.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

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

sleep()方法和wait()方法的区别：

①wait()方法是来源于Object类的方法，sleep()方法是来源于Thread类的方法

②wait()方法调用之后，会释放锁对象和CPU执行权；sleep()方法只释放CPU执行权，不释放锁对象

---

作者: 唐彬桂    时间: 2019-3-26 21:44
1.多线程的实现有几种方式？实现步骤分别是怎样的？
创建多线程程序的第一种方式:创建Thread类的子类
java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类
实现步骤:
    1.创建一个Thread类的子类
    2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
    3.创建Thread类的子类对象
    4.调用Thread类中的方法start方法,开启新的线程,执行run方法
         void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
         结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。
         多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行

创建多线程程序的第二种方式:实现Runnable接口
java.lang.Runnable
    Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的 Thread 对象。
    Thread(Runnable target, String name) 分配新的 Thread 对象。
实现步骤:
    1.创建一个Runnable接口的实现类
    2.在实现类中重写Runnable接口的run方法,设置线程任务
    3.创建一个Runnable接口的实现类对象
    4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    5.调用Thread类中的start方法,开启新的线程执行run方法


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类继承Thread，则不适合资源共享。
但是如果实现了Runable接口的话，则很容易的实现资源共享。

Runnable接口的优势：
    1.避免了单继承的局限性
        一个类只能继承一个类,类继承了Thread类就不能继承其他的类
        实现了Runnable接口,还可以继承其他的类,实现其他的接口
    2.增强了程序的扩展性,降低了程序的耦合性(解耦)
        实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
        实现类中,重写了run方法:用来设置线程任务
        创建Thread类对象,调用start方法:用来开启新线程

3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题是：多线程访问了共享的数据，就会产生线程安全问题。

解决线程的安全问题有：
1.同步代码块
2.同步方法
3.lock锁

4.sleep()方法和wait()方法的区别？
sleep()方法：进入睡眠，只会释放cpu的执行，锁不会释放出去。
wait()方法：进入到WAITING状态(无限等待)，会释放cpu和锁，需要唤醒。

---

作者: 刘曾铭    时间: 2019-3-26 21:44
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式。
（1）一种是定义一个类继承Thread类，在类中重写run();方法，然后在主方法中创建对象并调用start();方法开始新线程。
（2）第二种是创建实现类实Runnable接口，在实现类中重写run();方法，在主方法中创建创建Thread类对象和实现类对象并在构造方法中传递Runnable接口的实现类对象然后调用start();对象

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）因在只是单单继承一个Thread只是单继承并不能多实现而实现了Runnable接口则可以实现资源更多的共享
（2）1.可以避免单继承的尴尬
         2.使程序更加具有解耦性
         3.实现资源共享

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
（1）因为当有多个线程调用方法当中的变量，如果同步进行则线程安全，如果有sleep();或者wait(long timeout)等其他让线程停顿的方法时线程进行不同步则会让变量输出变得混乱从而影响线程安全。
（2）有3种方法
1. 同步代码块：运用synchronized(同步锁){需要同步操作的代码}  把大括号里的内容锁住让线程把大括号里程序走完。
2. 同步方法：即为synchronized修饰的方法，则是保证线程在执行该方法时其他线程在外面等待。
3. 锁机制：新建一个ReentrantLock()对象，调用lock和unlock方法加同步锁和释放同步锁使用格式执行同步操作代码前加同步锁方法，结束后执行释放同步锁方法


4.sleep()方法和wait()方法的区别？
（1）1.sleep方法是在Thread类中
         2.sleep方法在执行时是释放CPU执行权，不会释放锁
（2）1.wait是Object类中的方法
         2.wait方法不仅释放CPU执行权还会释放锁。

---

作者: 开心的小孩    时间: 2019-3-26 21:44

陈鹏涛
1.多线程的实现有几种方式？实现步骤分别是怎样的？
          2种：继承Thread类  实现 Runnable接口
Thread类：
      1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。
      2. 创建Thread子类的实例，即创建了线程对象
      3. 调用线程对象的start()方法来启动该线程

Runnable：
     实现步骤:
    1.创建一个Runnable接口的实现类
    2.在实现类中重写Runnable接口的run方法,设置线程任务
    3.创建一个Runnable接口的实现类对象
    4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    5.调用Thread类中的start方法,开启新的线程执行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
     区别：
            如果一个类继承Thread，则不适合资源共享。
            但是如果实现了Runable接口的话，则很容易的实现资源共享

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


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
         .线程安全问题：
                      多线程  多线程共享一个资源，进行修改资源

   线程安全是不能

        解决线程安全问题方式  ：
                      1使用同步代码块
                      2使用同步方法：
                      3静态的同步方法
4.sleep()方法和wait()方法的区别？
         sleep()方法   ：
                  来自于Thread类
                 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性
                sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
          wait()方法：
                来自Object类
                 唤醒的线程将无法继续，直到当前线程释放该对象上的锁。
                可以理解为多个线程之间的协作关系， 多个线程会争取锁，同时相互之间又存在协作关系。
           
   

---

作者: 曾伟清    时间: 2019-3-26 21:44
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种，一种是继承Thread类方式，一种是实现Runnable接口方式。
（1）继承Thread类方式：创建一个子类继承Thread类，重写里面的run（）方法，创建该子类对象，调用start（）方法。
（2）实现Runnable接口方式：创建一个Runnable实现类，重写run（）方法，通过Thread的有参构造方法将Runnable实现类作为参数，创建一个Thread对象调用start（）方法。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：区别：（1）继承Thread类子类可以设置线程任务和开启新线程，实现Runnable接口只能设置线程任务；
（2）子类继承Thread类就不能继承其他类了，实现类实现Runnable接口还可以实现别的借口，还可以继承其他类。
优点：（1）实现Runnable接口增强程序的拓展性，降低程序啊的耦合性。将设置线程任务和开启新线程进行了分离。实现类中设置线程任务，创建thread对象调用start方法开启新线程。
我们可以将同一个线程任务共享，即开启三个线程，传入同一个实现类作为参数。
（2）一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类，实现了Runnable接口,还可以继承其他的类,实现其他的接口。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：如果多个线程同时运行，并且访问同一线程资源，且多个线程中对资源有写的操作，就会出现线程安全问题。
使用同步机制解决，有三种方式：（1）同步代码块。（2）同步方法。（3）Lock锁机制。
4.sleep()方法和wait()方法的区别？
答：（1）sleep()是thread类中方法，wait()是Object类中的方法。
（2）sleep()被调用时，只交出cpu执行权；wait()被调用时，同时交出cpu执行权和锁对象。

---

作者: 魏政    时间: 2019-3-26 21:45

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

有2种实现多线程的方式：

（1）继承Thread类，实现Thread类的run方法。随后在调用处建立子类的对象，并用子类的对象调用start方法，即可建立一条线程；

（2）实现Runnable接口，实现Runnable接口的run方法。随后在调用处建立实现类的对象，将对象传入Thread的有参构造方法中，建立Thread的

子类对象，并通过其调用start方法，至此也建立了一个线程。

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

继承Thread类后只需建立子类的对象，即可用其调用start方法，建立线程。而实现Runnable接口后需要先建立实现类的对象，再将其作为参数传入

Thread的有参构造方法中，建立Thread的子类对象，才能借助Thread的子类对象调用start方法，建立线程。

但是，继承Thread类后，该子类不能再继承其他父类，而实现Runnable接口则可以继承其他父类。此外，实现Runnable接口更符合“专人专事”的思想，

将功能实现和线程建立分开，有利于代码的维护与更新。

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

当多个线程共享一份数据，并试图对该数据进行修改时容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。

解决线程安全一般有三种方式：

（1）同步代码块，即将synchronized 关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式：synchronized(同步锁){需要同步操作的代码}，多个线程必须使用同一把同步锁。

（2）同步方法，即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：public synchronized void method(){可能会产生线程安全问题的代码}。

（3）Lock锁，也称同步锁，将加锁与释放锁方法化了，用lock()方法加同步锁，用unlock()方法释放同步锁，在这两个方法之间的代码对线程具有排他性，即同一时间只允许一个线程

执行该段代码。

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

sleep()方法：参数列表输入一个long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu的拥有权，但不会失去同步锁的拥有权。

wait()无参方法：程序运行到此处将进入无限睡眠，如果没有其他线程的notify方法唤醒就不会恢复运行。

wait()有参方法：数列表输入long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu和同步锁的拥有权，可以提前被notify唤醒。

---

作者: 林志鹏    时间: 2019-3-26 21:45
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式：第一种继承Thread类，第二种实现Runnable接口
继承Thread类步奏：
（1）定义Thread的子类，并且重写run()方法；run()方法体中就是需要执行的子线程任务
（2）创建Thread子类的线程对象
（3）调用线程对象的start()方法来开启新线程
实现Runnable接口步奏：
（1）创建Runnable接口的实现类
（2）在实现类中重写Runnable接口的run()方法设置线程任务
（3）创建Runnable接口的实现类对象
（4）创建Thread类对象，构造方法中传递Runnable接口的实现类对象
（5）调用Thread类中的start()方法开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：
（1）继承Thread的类不适合资源共享；实现Runnable接口的很容易实现资源共享
（2）继承Thread的方式,占用继承；实现Runnable接口的方式,不占用继承,而是占用一个接口位置;
（3）继承Thread的方式,耦合度太高；实现Runnable接口的方式,增强程序的扩展性，降低了程序的耦合性（解耦合）;

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题是由全局变量及静态变量产生的，如果每个线程对变量只有读操作没有写操作的话线程就是安全的；
若多个线程同时执行写操作，就需要考虑线程同步问题，这样就会产生线程安全问题。
解决线程安全问题的有三种方式：
（1）第一种接口安全方式：同步代码块：格式:synchronized(同步锁){需要同步操作的代码}，多个线程要想实现同步技术,必须使用同一个锁对象,锁对象可以是任意对象;
（2）第二种安全方式：同步方法 和静态同步方法：使用synchronized修饰,保证A线程执行该方法的时候,其他线程只能在方法外
格式：public synchronized void method(){可能会产生线程安全问题的代码};
（3）第三种安全方式：Lock锁：也称为同步锁：
格式：void lock()获取锁  void unlock()释放锁
步奏：
①在成员位置创建一个Reentrantlock对象
②可能出现问题的代码前调用Lock接口中的Lock获取锁
③可能出现安全梯的代码后调用unlock释放锁
注意：释放同步锁;一般会在finally中释放锁,保证资源不被浪费;

4.sleep()方法和wait()方法的区别？
sleep()方法是属于Thread类；sleep()方法让其休眠，休眠的时候继续拥有Lock锁同时让出CPU。
wait()方法是属于Object类；wait()让其进入等待状态，等待的时候线程会放弃对象锁同时让出CPU等待被调用唤醒。

---

作者: 庄家琦    时间: 2019-3-26 21:45
1.多线程的实现有几种方式？实现步骤分别是怎样的？

一、继承Thread类
1.子类继承Thread类
2.重写Thread类的run方法(执行的任务)
3.在测试类中创建子类对象
4.调用start方法开启线程
二、实现Rannable接口
1.实现类实现Runnable接口
2.重写接口中的run方法（线程任务）
3.在测试类中创建线程对象Thread，将实现类作为参数传递进去
4.调用start方法开启线程

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

继承Thread类有三个问题
一、继承Thread类,占用继承位,类就只有一个继承位，被占用了就不用继承其他共性内容了
二、继承Thread类，子类有两个功能，一个是创建线程对象，一个是定义了线程任务，我们希望将功能分开
三、我们使用继承Thread类，无法做到资源共享,每个线程都有自己独有的代码片段

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

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
出现的条件
1，多个线程
2，访问同一个数据
3，数据正在被进行修改

同步代码块
synchronized(同步锁){需要同步操作的代码}   
注意事项：同步代码块的锁对象可以是任意对象，但是必须保证多个线程的锁对象是一个

同步方法
普通的同步方法
public synchronized void method(){
可能会产生线程安全问题的代码
}   
静态的同步方法
public staticsynchronized void method(){
可能会产生线程安全问题的代码
}   

对于普通的同步方法，锁对象是this
对应静态的同步方法，锁对象是类名.class字节码对象

Lock锁
Lock lock = new ReentrantLock();//创建锁对象
lock.lock();开启锁
包裹的代码——需要同步的代码
lock.unlock();释放锁

4.sleep()方法和wait()方法的区别？
sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动苏醒。sleep方法进入到睡眠不会释放锁对象
wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

---

作者: 王旭艺    时间: 2019-3-26 21:45
1.多线程的实现有几种方式？实现步骤分别是怎样的？
    (1)一种是继承Thread类方式
    步骤是:
    a. 创建一个Thread类的子类
    b. 在Thread类的子类中重写Thread类中的run方法,设置线程任务
    c. 创建Thread类的子类对象
    d. 调用Thread类中的方法start方法,开启新的线程,执行run方法

   (2)一种是实现Runnable接口方式
   步骤：
    a. 创建一个Runnable接口的实现类
    b. 在实现类中重写Runnable接口的run方法,设置线程任务
    c. 创建一个Runnable接口的实现类对象
    d. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    e. 调用Thread类中的start方法,开启新的线程执行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
     如果一个类继承Thread，则不适合资源 共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
     实现Runnable接口比继承Thread类所具有的优势：
(1) 适合多个相同的程序代码的线程去共享同一个资源。
(2) 可以避免java中的单继承的局限性。
(3) 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
(4）线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
前提：多个线程在执行同一资源并对资源进行数据的修改
产生的安全问题：a.线程修改数据，会产生重复的数据;b.线程会产生不存在的数据
解决方式：a.同步代码块
          b.同步方法
          c.Lock锁

4.sleep()方法和wait()方法的区别？
    sleep()方法使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
     wait()方法，无限期等待另一个线程执行一个特别的（唤醒）动作的线程
     sleep()方法源于Thread类让线程进入睡眠，指定了睡眠时间，时间一到自动苏醒。它进入到睡眠不会释放对象。
      wait()方法源于Object类，让线程进入等待，指定等待时间或者不指定知道其他线程唤醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

---

作者: 魏政    时间: 2019-3-26 21:45
1.多线程的实现有几种方式？实现步骤分别是怎样的？

有2种实现多线程的方式：
（1）继承Thread类，实现Thread类的run方法。随后在调用处建立子类的对象，并用子类的对象调用start方法，即可建立一条线程；
（2）实现Runnable接口，实现Runnable接口的run方法。随后在调用处建立实现类的对象，将对象传入Thread的有参构造方法中，建立Thread的
子类对象，并通过其调用start方法，至此也建立了一个线程。

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

继承Thread类后只需建立子类的对象，即可用其调用start方法，建立线程。而实现Runnable接口后需要先建立实现类的对象，再将其作为参数传入
Thread的有参构造方法中，建立Thread的子类对象，才能借助Thread的子类对象调用start方法，建立线程。
但是，继承Thread类后，该子类不能再继承其他父类，而实现Runnable接口则可以继承其他父类。此外，实现Runnable接口更符合“专人专事”的思想，
将功能实现和线程建立分开，有利于代码的维护与更新。

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

当多个线程共享一份数据，并试图对该数据进行修改时容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。
解决线程安全一般有三种方式：
（1）同步代码块，即将synchronized 关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式：synchronized(同步锁){需要同步操作的代码}，多个线程必须使用同一把同步锁。
（2）同步方法，即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：public synchronized void method(){可能会产生线程安全问题的代码}。
（3）Lock锁，也称同步锁，将加锁与释放锁方法化了，用lock()方法加同步锁，用unlock()方法释放同步锁，在这两个方法之间的代码对线程具有排他性，即同一时间只允许一个线程
执行该段代码。

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

sleep()方法：参数列表输入一个long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu的拥有权，但不会失去同步锁的拥有权。
wait()无参方法：程序运行到此处将进入无限睡眠，如果没有其他线程的notify方法唤醒就不会恢复运行。
wait()有参方法：数列表输入long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu和同步锁的拥有权，可以提前被notify唤醒。

---

作者: 叶彬彬    时间: 2019-3-26 21:46
1.多线程的实现有几种方式？实现步骤分别是怎样的？
Thread：
1.创建一个Thread的子类
2.重写run()方法
3.创建一个Thread的子类的对象
4.调用star()方法
Runnable：
1.创建一个Runnable的实现类
2.重写run()方法
3.创建Runnable的实现类对象
4.创建Thread对象，并把Runnable的实现类对象当参数传递给Thread
5.调用star()方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
优势：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生原因：多个线程访问同一资源的时候，且多个线程对资源有写操作的时候，就容易出现线程安全问题
解决方法：
同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
同步方法：使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
Lock锁：同步代码块/同步方法具有的功能Lock都有,Lock锁也称同步锁，加锁与释放锁方法化了

4.sleep()方法和wait()方法的区别？
sleep()方法休眠时携带着锁对象；wait()方法休眠时释放锁对象
sleep()方法来源于Thread类；wait()来源于Object类

---

作者: 陈鉴    时间: 2019-3-26 21:46
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式。一种是通过创建子类继承Thread，重写run方法，创建子类对象，调用start方法。另一种是通过实现runnable接口，重写run方法，创建实现类对象，创建Thread对象，把接口实现类对象作为Thread的构造参数传递进去，再通过Thread对象来调用start方法，开启新线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1.继承的特点是单继承，而实现的特点是多实现。因此，继承Thread就无法继承其他类，而实现runable接口还能去实现其他接口，去继承类；
2.继承Thread类，创建子类对象后，开启线程和运行线程任务是绑定在一起的，耦合度太高，不利于后期修改，以及线程任务的共享；而实现runable接口则接口的实现类中设置线程任务，开启线程通过创建Thread对象，则两者是分开的，降低耦合度，增强了程序的拓展性。
优势：耦合性低，线程任务和线程对象分开；可以反复使用线程任务，实现资源共享。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多条线程共用资源且执行写操作时就会发生线程安全问题。
用同步代码块（synchronized关键字）；用同步方法；用lock锁（lock和unlock方法）

4.sleep()方法和wait()方法的区别？
sleep是Thread类中的方法；不释放同步锁；时间到，自动唤醒
wait是object的方法；释放同步锁；需要notify方法来唤醒，否则就一直无限等待。

---

作者: 龚荣章    时间: 2019-3-26 21:46
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种
第一种:定义Thread类的子类,并重写run()方法,该run()方法的方法体就代表了线程需要完成的任务,再创建Thread子类的实例,即创建了线程对象,再调用线程兑现的start()方法来启动该线程
第二种:定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体,再创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象.再调用线程对象的start()方法来启动线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类继承Thread,则不适合资源共享.但是如果是想了Runable接口的话,则很容易的实现资源共享
优势:
1.适合多个相同的程序代码的线程去共享同一个资源
2.可以避免java中的单继承局限性
3.增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
4.线程池只能放入实现Runnable或者Callable类线程,不能直接放入继承Thread的类
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当我们要用多个线程对共享数据进行修改的时候，由于CPU的是高速在多个线程之间切换执行的，所以在修改共享数据的时候就有可能出现问题（例如：卖票案例中，出现了一张票被卖了多次等）
解决方案：
第一种方式：同步代码块
        将可能会出现线程安全问题的代码抽取到synchronize代码块中
        格式 ： synchronize（锁对象）{可能会出现问题的代码}
第二种方式：同步方法
        把访问了共享数据的代码抽取到一个方法中，并用synchronize修饰该方法
        格式：修饰符 synchronize 返回值类型 方法名（参数列表）{ 方法体 }
第三种方式：Lock锁
（1）        在成员位置创建一个ReentrantLock对象
（2）        在可能出现安全问题的代码前调用Lock接口中的lock（）方法获取锁
（3）        在可能出现安全问题的代码后调用Lock接口中的unlock（）方法释放锁
4.sleep()方法和wait()方法的区别？
线程执行sleep()方法时只会放弃cup占用权不会放弃锁的执行权
在执行wait()时会放弃cup占用权和锁的执行权

---

作者: 吴越    时间: 2019-3-26 21:46
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现方式有两种，分别是通过【Thread子类】和【Runnable接口】实现的。
【创建Thread子类方法的实现步骤】：
①创建一个Thread类的子类，并重写Thread类中的run方法，设置线程任务；
②创建Thread类的子类对象；
③调用线程对象的start()方法，开启新的线程，执行run方法；
【创建Runnable接口方法的实现步骤】：
①创建一个Runnable接口的实现类；
②在实现类中重写Runnable接口的run方法，设置线程任；
③创建一个Runnable接口的实现类对象；
④创建Thread类对象，构造方法中传递Runnable接口的实现类对象；
⑤调用Thread类中的start方法，开启新的线程执行run方法；

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：【区别】继承Thread类中子类既具有创建线程对象的功能，又具有线程任务的功能。Runnable接口只具备线程任务的功能，创建对象交给Thread对象。
【Runnable接口的优势】
①可以避免java中的单继承的局限性，使继承位空出，而接口是可以实现多个的。       
②实现了【实现线程任务】和【创建线程对象】操作的分离，降低了耦合性。
③一个Runnable接口中实现的线程任务可以被多个线程对象共享使用，提高了代码的复用性。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
【产生】：当多个线程对象访问同一个资源，并且多个线程中对资源有写的操作，就容易产生线程安全问题。
【解决】：解决线程安全问题，主要有三种方式：同步代码块、同步方法、Lock锁。
【同步代码块】：把可能产生线程安全问题的代码放入synchronized 关键字修饰的代码块中，表示对这个区块的资源实行互斥访问。
【同步方法】：使用synchronized修饰的方法，就叫做同步方法，保证一个线程执行该方法的时候，其他线程只能在方法外等着。
【Lock锁】：通过ReentrantLock()方法生成Lock对象，在可能产生线程安全问题的代码前用lock()方法加同步锁，在可能产生线程安全问题的代码后用unlock()释放同步锁。

4.sleep()方法和wait()方法的区别？
答：【sleep()方法】是Thread类中的静态方法，让当前正在执行的线程休眠（暂停执行）。sleep()方法必须传入long类型的参数，作为休眠的时长（毫秒），时间到后会自动唤醒，无法提前主动唤醒。sleep方法使用后线程失去CPU执行权，但仍然拥有锁对象。
【wait()方法】是Object类中的成员方法，让当前线程等待。wait()方法既可以传入参数作为自动唤醒的时间量，也可以通过notify() 方法或notifyAll() 方法主动唤醒。同时，wait()方法可也以不传入参数调用，使得当前线程在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，永远处于等待状态。wait方法同时释放锁对象和cpu执行权。

---

作者: 陈前凌    时间: 2019-3-26 21:46
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式：
第一种方式：继承 Thread 类
1.定义一个子线程的类，继承 Thread 类；
2.在子线程类中重写 run 方法，在 run 方法中打印子线程的名称；
3.定义一个测试类；
4.在 main 方法中打印主线程的名称；
5.在 main 方法中创建子线程对象；
6.调用子线程对象的 start 方法，开启子线程
第二种实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread中的start方法，开启新的线程执行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程访问共享数据，并对这个资源中的数据执行修改操作的时候，会发生线程安全问题。
1.同步代码块
2.同步方法
3.Lock锁

4.sleep()方法和wait()方法的区别？
1.wait方法是来源于Object类的方法，sleep是来源于Thread

2.wait释放锁了cpu，sleep值释放cpu

---

作者: 魏政    时间: 2019-3-26 21:46
1.多线程的实现有几种方式？实现步骤分别是怎样的？

有2种实现多线程的方式：
（1）继承Thread类，实现Thread类的run方法。随后在调用处建立子类的对象，并用子类的对象调用start方法，即可建立一条线程；
（2）实现Runnable接口，实现Runnable接口的run方法。随后在调用处建立实现类的对象，将对象传入Thread的有参构造方法中，建立Thread的
子类对象，并通过其调用start方法，至此也建立了一个线程。

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

继承Thread类后只需建立子类的对象，即可用其调用start方法，建立线程。而实现Runnable接口后需要先建立实现类的对象，再将其作为参数传入
Thread的有参构造方法中，建立Thread的子类对象，才能借助Thread的子类对象调用start方法，建立线程。
但是，继承Thread类后，该子类不能再继承其他父类，而实现Runnable接口则可以继承其他父类。此外，实现Runnable接口更符合“专人专事”的思想，
将功能实现和线程建立分开，有利于代码的维护与更新。

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

当多个线程共享一份数据，并试图对该数据进行修改时容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。
解决线程安全一般有三种方式：
（1）同步代码块，即将synchronized 关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式：synchronized(同步锁){需要同步操作的代码}，多个线程必须使用同一把同步锁。
（2）同步方法，即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：public synchronized void method(){可能会产生线程安全问题的代码}。
（3）Lock锁，也称同步锁，将加锁与释放锁方法化了，用lock()方法加同步锁，用unlock()方法释放同步锁，在这两个方法之间的代码对线程具有排他性，即同一时间只允许一个线程
执行该段代码。

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

sleep()方法：参数列表输入一个long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu的拥有权，但不会失去同步锁的拥有权。
wait()无参方法：程序运行到此处将进入无限睡眠，如果没有其他线程的notify方法唤醒就不会恢复运行。
wait()有参方法：数列表输入long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu和同步锁的拥有权，可以提前被notify唤醒。

---

作者: 蓝建华    时间: 2019-3-26 21:46
1.throw和throws的区别？
答：
      throw是抛出异常，即在方法中抛出指定的异常对象，将这个异常对象传递给方法的调用者，同时结束当前方法
      throw时声明异常，表示当前方法不处理的异常。而是将异常给调用处。如果方法内通过throw抛出异常，而没有用try..catch处        理，那么就必须通过throws进行声明，让方法的调用者去处理
2.什么时候需要声明异常，什么时候不需要声明异常？
答：
     如果方法中有throw抛出异常且没有try..catch来处理，那么必须在方法中声明异常，将异常交给调用者处理。声明时可以同时声明多个异常，用逗号隔开。如果方法进入运行期，则不需要声明异常，交给JVM虚拟机处理
3.异常有几种处理方式？
答：
     二种，一个是声明异常，一种是tey..catch处理异常
4.什么是并发，什么是并行？
答：
     并发：是指二个或者多个事件在同一时间段发生
     并行：是指二个或者多个事件在同一时该发生
5.什么是进程，什么是线程？
     进程：进程是指一个内存中运行的应用，每个进程都有一个独立的内存空间，一个应用程序可以同时运行uoge进程，进程也是程序一个执行过程，是系统运行的基本单位，运行系统一个程序即是一个进程冲创建运行到消失的过程
     线程：线程是进程中的要给执行单元，负责当前进程中的程序的执行，一个进程中必须有个线程，一个进程中可以有多个线程，这个程序也可以叫做多线程程序；
6.run()方法和start()方法的区别？
答：
     run()方法中的储存的是执行体，如果直接在mian方法中调用那么就不会创建一个新的线程
     start（）在mian方法中调用它的话就直接创建了一个新的线程来调用run()方法

---

作者: 林艺彬    时间: 2019-3-26 21:48
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种：
第一种方式是将类声明为 Thread 的子类。
1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象。
3. 调用线程对象的start()方法来启动该线程。
第二种方式是声明一个类实现Runnable 接口。
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口比继承Thread类所具有的优势：
（1） 适合多个相同的程序代码的线程去共享同一个资源。
（2）可以避免java中的单继承的局限性。
（3）增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
（4）线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：多线程访问了共享的数据，会产生线程安全问题。
三种方式：同步代码块、同步方法、Lock锁。

4.sleep()方法和wait()方法的区别？
Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。

---

作者: 黄振明    时间: 2019-3-26 21:48
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程有两种实现方式
Thread类：
        1.子类继承Thread类
        2.重写run()方法
        3.创建子线程对象
        4.调用Thread类中的start()方法，开启线程
Runnable接口：
        1.创建Runnable接口的实现类
        2.重写run()方法
        3.创建实现类对象
        4.创建Thread类对象,构造方法中传递实现类对象
        5.调用start()方法，开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
（1）子类即具有创建线程对象的功能，有具有线程任务的功能（耦合性太高）
（2）一个类可以继承一次，实现多次，占用继承位
（3）多个线程无法共享同一资源
好处：
（1）避免了单继承的局限性
（2）增强了程序的扩展性，降低了程序的耦合性

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：当多个线程操作同一个资源，并对这个资源的数据进行修改操作的时候，就会出现线程安全问题。
方案一：同步代码块
方案二：同步方法
使用步骤：
        1.把访问了共享数据的代码抽取出来，放到一个方法中
        2.在方法上添加synchronized修饰符       
方案三：Lock锁
使用步骤：
        1.在成员位置创建一个ReentrantLock对象
        2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
        3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

4.sleep()方法和wait()方法的区别？
答：
sleep()方法：sleep()方法是让线程休眠，在指定的时间过后会继续执行后面的代码
wait()方法：首先wait()方法是Object类的一个方法，wait()无参方法是让线程进入无限等待状态，需要调用notify()方法唤醒
wait()有参方法与sleep()方法相似，在指定的时间过后通过调用notify()方法唤醒
wait方法调用后会释放锁对象和CPU执行权；sleep方法只释放CPU执行权

---

作者: 6期江岳    时间: 2019-3-26 21:48
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种：(1)创建Thread的子类，重写run()方法，在测试类中创建子类对象，通过子类对象调用Start方法执行run方法内容
(2)创建Runable接口的实现类，重写run方法，在测试类中创建实现类对象，创建以接口实现类为参数的Thread对象，通多Thread对象调用Start方法执行run方法内容。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread的继承类不适合资源共享，Runable接口的实现类，则很容易的实现资源共享。
优势：1. 适合多个相同的程序代码的线程去共享同一个资源。
          2. 可以避免java中的单继承的局限性。
          3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
          4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题都是由全局变量及静态变量引起的。在没有考虑线程同步问题，就让多个对象对全局变量或静态变量进行写操作。
考虑线程同步解决线程安全问题。方法：1、同步代码块   2、同步方法   3、Lock锁
4.sleep()方法和wait()方法的区别？
sleep()方法执行时会放弃CPU，但不会放弃锁对象。
wait()方法执行时，都放弃了对CPU和锁对象的竞争。

---

作者: 蓝建华    时间: 2019-3-26 21:48
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
    有两种方式，一种是通过继承Thread类和实现Runnable接口：
    继承Thread类的步骤：1.定义一个Therad子类2.重写run方法，方法内写入需要执行的方法体3.创建Therad子类对象4.调用Therad中的starrt方法来开启子线程和执行run方法

     实现Runnable接口步骤：1.创建实现类2，重写run方法，方法中写入需要执行的方法体3.创建实现类对象4.创建Therad对象，调用构造方法传入实现类5.调用线程对象的start方法创建新的线程，并执行rum方法   
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答;
     1.使用继承的方式，占用继承位，使用实现类的方式，不占继承位
     2.如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很           容易的实现资源共享。
     3..使用继承的方式,耦合度太高,两个功能写在一起;使用实现的方式,两个功能拆开,解耦合;
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
      当多线程访问共享数据并执行写操作时，就会发生线程安全问题；
      解决线程问题有三种方式：
      方案一：同步代码块（锁对象为任意对象   obj）
      方案二：同步方法（锁对象是实现类本身，也就是this）
      方案三：静态方法（锁对象是本类的class对象--RunnableImpl.class）

4.sleep()方法和wait()方法的区别？
    sleep()参数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。
     而wait（）无参方法将进入无限睡眠，如果没有notify方法唤醒就不会恢复运行
     wait()数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。不过可以提     前被notify 唤醒

---

作者: 卢勇炜    时间: 2019-3-26 21:50
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：（1）继承Thread类 ：首先新建一个类来继承Thread类；在继承类中重写Thread类中的run方法，在run写任务代码；
；创建继承类对象；调用start方法来开启线程
      （2）实现Runnable接口：首先新建一个接口实现类，重写run方法，在run方法中写任务代码；创建接口实现类对象；
创建Thread对象，传入接口实现类对象作为参数；调用start方法开启线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类单继承；而Runnable接口是实现类，可以实现多个接口；继承Thread类子类耦合度太高；而Runnable接口只是实现线程的任务功能，Runnable接口可以创建多个对象来共享资源；

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：同一块代码区域被多条线程进行改写造成的线程安全问题；有三种形式：同步代码块；同步方法；锁机制；

4.sleep()方法和wait()方法的区别？
答：sleep()方法是Thread,wait()方法是Object,sleep()进入睡眠是不会还锁的,而wait()休眠期间会释放锁的

---

作者: 林志鹏    时间: 2019-3-26 21:51
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式：第一种继承Thread类，第二种实现Runnable接口
继承Thread类步奏：
（1）定义Thread的子类，并且重写run()方法；run()方法体中就是需要执行的子线程任务
（2）创建Thread子类的线程对象
（3）调用线程对象的start()方法来开启新线程
实现Runnable接口步奏：
（1）创建Runnable接口的实现类
（2）在实现类中重写Runnable接口的run()方法设置线程任务
（3）创建Runnable接口的实现类对象
（4）创建Thread类对象，构造方法中传递Runnable接口的实现类对象
（5）调用Thread类中的start()方法开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：
（1）继承Thread的类不适合资源共享；实现Runnable接口的很容易实现资源共享
（2）继承Thread的方式,占用继承；实现Runnable接口的方式,不占用继承,而是占用一个接口位置;
（3）继承Thread的方式,耦合度太高；实现Runnable接口的方式,增强程序的扩展性，降低了程序的耦合性（解耦合）;

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题是由全局变量及静态变量产生的，如果每个线程对变量只有读操作没有写操作的话线程就是安全的；
若多个线程同时执行写操作，就需要考虑线程同步问题，这样就会产生线程安全问题。
解决线程安全问题的有三种方式：
（1）第一种接口安全方式：同步代码块：格式:synchronized(同步锁){需要同步操作的代码}，多个线程要想实现同步技术,必须使用同一个锁对象,锁对象可以是任意对象;
（2）第二种安全方式：同步方法 和静态同步方法：使用synchronized修饰,保证A线程执行该方法的时候,其他线程只能在方法外
格式：public synchronized void method(){可能会产生线程安全问题的代码};
（3）第三种安全方式：Lock锁：也称为同步锁：
格式：void lock()获取锁  void unlock()释放锁
步奏：
①在成员位置创建一个Reentrantlock对象
②可能出现问题的代码前调用Lock接口中的Lock获取锁
③可能出现安全梯的代码后调用unlock释放锁
注意：释放同步锁;一般会在finally中释放锁,保证资源不被浪费;

4.sleep()方法和wait()方法的区别？
sleep()方法是属于Thread类；sleep()方法让其休眠，休眠的时候继续拥有Lock锁同时让出CPU。
wait()方法是属于Object类；wait()让其进入等待状态，等待的时候线程会放弃对象锁同时让出CPU等待被调用唤醒。

---

作者: 李伟艺    时间: 2019-3-26 21:51
1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread，实现runtime接口，但实际上都是实现了runtime接口，而继承Thread类还有单继承局限
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口的优势： 1. 适合多个相同的程序代码的线程去共享同一个资源。 2. 可以避免java中的单继承的局限性。 3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。 4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样 的，而且其他的变量的值也和预期的是一样的，就是线程安全的。线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全
4.sleep()方法和wait()方法的区别？
Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。
5.线程有几种状态？他们之间是如何转化的？
NEW(新建) 线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行) 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。
Blocked(锁阻 塞) 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限 等待) 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时 等待) 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated(被 终止) 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

---

作者: 林志鹏    时间: 2019-3-26 21:52
1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式：第一种继承Thread类，第二种实现Runnable接口
继承Thread类步奏：
（1）定义Thread的子类，并且重写run()方法；run()方法体中就是需要执行的子线程任务
（2）创建Thread子类的线程对象
（3）调用线程对象的start()方法来开启新线程
实现Runnable接口步奏：
（1）创建Runnable接口的实现类
（2）在实现类中重写Runnable接口的run()方法设置线程任务
（3）创建Runnable接口的实现类对象
（4）创建Thread类对象，构造方法中传递Runnable接口的实现类对象
（5）调用Thread类中的start()方法开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：
（1）继承Thread的类不适合资源共享；实现Runnable接口的很容易实现资源共享
（2）继承Thread的方式,占用继承；实现Runnable接口的方式,不占用继承,而是占用一个接口位置;
（3）继承Thread的方式,耦合度太高；实现Runnable接口的方式,增强程序的扩展性，降低了程序的耦合性（解耦合）;

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题是由全局变量及静态变量产生的，如果每个线程对变量只有读操作没有写操作的话线程就是安全的；
若多个线程同时执行写操作，就需要考虑线程同步问题，这样就会产生线程安全问题。
解决线程安全问题的有三种方式：
（1）第一种接口安全方式：同步代码块：格式:synchronized(同步锁){需要同步操作的代码}，多个线程要想实现同步技术,必须使用同一个锁对象,锁对象可以是任意对象;
（2）第二种安全方式：同步方法 和静态同步方法：使用synchronized修饰,保证A线程执行该方法的时候,其他线程只能在方法外
格式：public synchronized void method(){可能会产生线程安全问题的代码};
（3）第三种安全方式：Lock锁：也称为同步锁：
格式：void lock()获取锁  void unlock()释放锁
步奏：
①在成员位置创建一个Reentrantlock对象
②可能出现问题的代码前调用Lock接口中的Lock获取锁
③可能出现安全梯的代码后调用unlock释放锁
注意：释放同步锁;一般会在finally中释放锁,保证资源不被浪费;

4.sleep()方法和wait()方法的区别？
sleep()方法是属于Thread类；sleep()方法让其休眠，休眠的时候继续拥有Lock锁同时让出CPU。
wait()方法是属于Object类；wait()让其进入等待状态，等待的时候线程会放弃对象锁同时让出CPU等待被调用唤醒。

---

作者: 厦门第六期刘鹏    时间: 2019-3-26 21:52
1.多线程的实现有几种方式？
    答：有两种
  实现步骤分别是怎样的？
    答：（1）继承Thread类
        1.子类继承Thread类
        2.重写Thread类的run方法
        3.在测试类中创建子类对象
        4.调用start方法开启线程
        （2）实现Rannable接口
        1.实现类实现Runnable接口
        2.重写接口中的run方法
        3.在测试类中创建线程对象Thread，将实现类作为参数传递进去
        4.调用start方法开启线程   
2.继承Thread类和实现Runnable接口有啥区别？
    答：继承Thread类：占用了继承位；在Thread之类中重写run（）方法，不能够实现多个线程执行同一段代码。耦合度太高。
           实现Runnable接口：实现了Runnable接口还能继承其它类，在Runnable实现类重写run（）方法，通过构造方法传入Runnable实现类对象作为参数创建Thread类     象调用start（）方法开启新线程，可以实现多个线程执行同一段代码，降低了耦合度。
实现Runnable接口的优势体现在哪里？
  答：优势：
（1）        避免了单继承的局限性
（2）        增强了程序的扩展性，降低了程序的耦合性
（3）        实现了Runnable接口的方式，将线程任务和开启新线程进行了分离。
3.线程安全问题时怎么产生的？
    答：[多个线程]在执行[同一资源]并对这个资源进行[数据的修改]
    如何解决线程安全问题，有哪几种方式？
    答：有三种方法，分别是：1.同步代码块 2.同步方法 3.Lock锁
4.sleep()方法和wait()方法的区别？
    答：sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动
苏醒。sleep方法进入到睡眠不会释放锁对象
          wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤
醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执
行权

---

作者: 黄成龙    时间: 2019-3-26 21:53
1.多线程的实现有几种方式？实现步骤分别是怎样的？
有2种实现多线程的方式：
（1）继承Thread类，实现Thread类的run方法。随后在调用处建立子类的对象，并用子类的对象调用start方法，即可建立一个线程；
（2）实现Runnable接口，实现Runnable接口的run方法。随后在调用处建立实现类的对象，将对象传入Thread的有参构造方法中，建立Thread的子类对象，并通过其调用start方法，建立一个线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：继承Thread类只需建立子类的对象，即可用其调用start方法，建立线程。而实现Runnable接口需要先建立实现类的对象，再将其作为参数传入。Thread的有参构造方法中，建立Thread的子类对象，才能借助Thread的子类对象调用start方法，建立线程。但是，继承Thread类后，该子类不能再继承其他父类，而实现Runnable接口则可以继承其他父类。此外，实现Runnable接口更符合“专人专事”的思想。
实现Runnable接口的优势是：将功能实现和线程建立分开，有利于代码的维护与更新。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享一份数据，并试图对该数据进行修改时容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。
解决线程安全一般有三种方式：
（1）同步代码块，即将synchronized关键字用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
        格式：synchronized(同步锁){需要同步操作的代码}，多个线程必须使用同一把同步锁。
（2）同步方法，即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
        格式：public synchronized void method(){可能会产生线程安全问题的代码}。
（3）Lock锁，也称同步锁，将加锁与释放锁方法化了，用lock()方法加同步锁，用unlock()方法释放同步锁，在这两个方法之间的代码对线程具有排他性，即同一时间只允许一个线程执行该段代码。

4.sleep()方法和wait()方法的区别？
sleep()方法：参数列表输入一个long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu的拥有权，但不会失去同步锁的拥有权。
wait()无参方法：程序运行到此处将进入无限睡眠，如果没有其他线程的notify方法唤醒就不会恢复运行。
wait()有参方法：数列表输入long值 ，表示毫秒值，代表程序在此处休眠指定毫秒后将自动恢复运行，在休眠期间，该线程将失去cpu和同步锁的拥有权，可以提前被notify唤醒。

---

作者: JavaEE06蒋才东    时间: 2019-3-26 21:54
1.多线程的实现有几种方式？实现步骤分别是怎样的？
Thread类：
1.子类继承Thread类
2.重写run方法
3.创建Thead对象
4.调用start方法

Runnable接口：
1.子类实现Runnable接口
2.重写run方法
3.创建Runnable对象
4.创建Thread对象
5.调用start方法       
               
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类，不能资源共享，实现Runnable接口，能资源共享
a. 适合多个相同的程序代码的线程去共享同一个资源。
b. 可以避免java中的单继承的局限性。
c. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
d. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程对同一个资源进行操作时，就会出现线程安全问题

同步代码块
同步方法
Lock锁

4.sleep()方法和wait()方法的区别？
sleep()方法是Thread类中方法，不需要锁对象，只释放CPU执行权
wait()方法是Object类中方法，需要锁对象，释放CUP执行权和锁对象

---

作者: 黑马6期陈华    时间: 2019-3-26 21:55


1.多线程的实现有几种方式？实现步骤分别是怎样的？
（1）自定义线程类子类对象：
        1.创建一个Thread类的子类；
        2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）；
        3.创建Thread类的子类对象；   
        4.调用Thread类中的start方法，开启新的线程，执行run方法。

（2）实现Runnable接口，重写run方法。
        1.创建一个Runnable接口的实现类；
        2.在实现类中重写Runnable接口的run方法，设置任务；
        3.创建Runnable接口的实现类对象；
        4.直接创建Thread类对象，构造方法中传递Runnalbe接口的实现类对象（不需要自定义线程类了）；
        5.调用Thread类中的start方法，开启新的线程执行run方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）继承Thread类：相对耦合度高。
（2）实现Runaable接口：相对耦合度低。
（3）优势：
        1.可以实现多接口，避免继承Thread类的单继承的局限性。
        2.适合多个线程的资源共享，提高了代码的复用性。
        3.使线程的创建和运行分离，实现解耦的目的。
3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
（1）产生的原因：如果多个线程在同时运行同一段代码，并且对同一份数据同时进行了读写的操作，那么就容易引起数据的错误，即为线程不安全。
（2）解决的方式：
        1.同步代码块：
        synchronized(Object 同步锁){
                可能导致线程安全问题的代码；
        }
        2.同步方法：
        修饰符 synchronized 返回值 方法名（参数列表）{
                可能导致线程安全问题的代码；
        }
        3.Lock锁：
                Lock lock = new ReentrantLock();
                lock.lock();
                可能导致线程安全问题的代码；
                lock.unlock();
4.sleep()方法和wait()方法的区别？
（1）sleep方法不会释放同步锁，而wait方法将释放同步锁；
（2）sleep方法属于Thread类，wait方法属于Object类。

---

作者: 卢春旭    时间: 2019-3-26 21:56
1.多线程的实现有几种方式？实现步骤分别是怎样的？
        第一种：
        1.子类继承Thread类
        2.重写Thread类的run方法(执行的任务)
          3.在测试类中创建子类对象
        4.调用start方法开启线程
        第二种：
        1.实现类实现Runnable接口
        2.重写接口中的run方法（线程任务）
        3.在测试类中创建线程对象Thread，将实现类作为参数传递进去
        4.调用start方法开启线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        1.继承Thread类占用了继承位，无法实现其他继承关系；而Runnable接口是实现类，不影响继承。
        2.继承Thread类子类既需要穿件对象，又有线程任务，耦合度太高；而Runnable接口只是实现线程的任务功能，
        3.继承Thread类多个对象无法共享资源；而Runnable接口可以创建多个对象是，实现资源共享。所以，Runnable接口避免了单继承性的局限性，又降低了耦合度
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        线程安全问题：当多个线程操作同一个资源，并对这个资源的数据进行修改操作的时候，就会出现线程安全问题
        1.同步代码块  synchronized(同步锁){
需要同步操作的代码
}   
2.同步方法
普通的同步方法
public synchronized void method(){
可能会产生线程安全问题的代码
}   
静态的同步方法
public staticsynchronized void method(){
可能会产生线程安全问题的代码
}   
对于普通的同步方法，锁对象是this
对应静态的同步方法，锁对象是类名.class字节码对象
        3.Lock锁
Lock lock = new ReentrantLock();    创建锁对象
lock.lock();开启锁
包裹的代码——需要同步的代码
lock.unlock();释放锁
4.sleep()方法和wait()方法的区别？
        sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动苏醒。sleep方法进入到睡眠不会释放锁对象
wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

---

作者: 黑马林伟明    时间: 2019-3-26 21:57

1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式,一种是通过继承,另一种是通过接口实现
继承:创建一个子类,继承Thread,重写父类中的run()方法,创建对象,开启线程
接口:创建一个接口实现类,实现Runnable接口,重写run()方法,创建对象,
再创建Thread将创建的对象传入Thread中,开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承:创建的每一个线程都是一个崭新的线程
实现:一个线程对象可以多次被开启
实现的优势:同一个线程可以多次被开启,一个子类只能继承一个父类,继承Thread会占用继承父类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题时怎么产生的:同一块代码区域被多条线程进行改写造成的线程安全问题;
如何解决线程安全问题:通过加synchronized来解决线程安全问题;有三种方式解决;
1)同步代码块
2)同步方法
3)锁机制

4.sleep()方法和wait()方法的区别？
sleep()属于Thread,wait()属于Object,sleep()休眠期间不会归还锁,wait()休眠期间会归还锁

---

作者: 龙舟    时间: 2019-3-26 21:59
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种，一种是继承Thread类方式，一种是实现Runnable接口方式。
（1）继承Thread类方式：创建一个子类继承Thread类，重写里面的run（）方法，
创建该子类对象，调用start（）方法。
（2）实现Runnable接口方式：创建一个Runnable实现类，重写run（）方法，
通过Thread的有参构造方法将Runnable实现类作为参数，创建一个Thread对象调用start（）方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）继承的特点是单继承，而实现的特点是多实现。因此，继承Thread就无法继承其他类，
而实现runable接口还能去实现其他接口，去继承类；
（2）继承Thread类，创建子类对象后，开启线程和运行线程任务是绑定在一起的，耦合度太高，
不利于后期修改，以及线程任务的共享；而实现runable接口则接口的实现类中设置线程任务，
开启线程通过创建Thread对象，则两者是分开的，降低耦合度，增强了程序的拓展性。
优势：耦合性低，线程任务和线程对象分开；可以反复使用线程任务，实现资源共享。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
（1）因为当有多个线程调用方法当中的变量，如果同步进行则线程安全，如果有sleep();或者wait(long timeout)等
其他让线程停顿的方法时线程进行不同步则会让变量输出变得混乱从而影响线程安全。
（2）有3种方法
1. 同步代码块：运用synchronized(同步锁){需要同步操作的代码}  把大括号里的内容锁住让线程把大括号里程序走完。
2. 同步方法：即为synchronized修饰的方法，则是保证线程在执行该方法时其他线程在外面等待。
3. 锁机制：新建一个ReentrantLock()对象，调用lock和unlock方法加同步锁和释放同步锁使用格式执行同步
操作代码前加同步锁方法，结束后执行释放同步锁方法

4.sleep()方法和wait()方法的区别？
sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动苏醒。sleep方法进入到睡眠不会释放锁对象

wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤醒。wait方法会释放锁对象，
wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

---

作者: 张广发    时间: 2019-3-26 21:59

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式 创建继承Thread的子类      new Thread(借口Runnable的实现类)
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
避免了单继承的局限性
增强了程序的扩展性,降低了程序的耦合性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
sleep并没有释放锁对象

---

作者: chenopen    时间: 2019-3-26 22:05
陈开明：
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种实现方式。
一种通过继承Thread实现。首先先定义一个继承Thread类的子类，然后重写run()方法，最后在主线程测试类中创建具体的Thread对象，调用start(）方法开启线程。
一种是通过创建Runnable接口的实现类来创建线程。首先先创建一个实现Runnable的实现类，然后在主线程测试类中创建Runnable实现类的具体对象，最后将这个对象作为参数，传递给Thread类，创建具体线程对象。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1、避免了单继承的局限性。2、增强了程序扩展性，降低了程序的耦合性。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程访问同一资源，且多个线程对资源有写的操作时候，就可能出现线程安全问题。
使用同步机制解决，有3种方法解决线程安全问题。
1、同步代码块。2、同步方法。3、锁方法。
4.sleep()方法和wait()方法的区别？
sleep()是线程暂停一段时间，其中没有释放对象锁。
wait()是线程暂停一段时间，其中释放了对象锁。

---

作者: 林奕全    时间: 2019-3-26 23:13
1.多线程的实现有几种方式？实现步骤分别是怎样的？

第一种:继承Thread类实现

步骤:

1.创建Thread类的子类,继承Thread类.

2.重写Thread类的run方法

3.创建子类对象

4.调用Thread类的Start方法,开启多线程任务,执行run方法.

第二种:实现Runnable接口

步骤:

1.创建Runnable接口的实现类,并重写run方法

2.创建一个实现类对象

3.创建一个Thread类对象,并将实现类对象作为参数传入

4.调用Thread类对象的Start方法,开启多线程任务,执行run方法.



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

如果一个类继承Thread类,则不适合资源共享,而实现Runnable接口的话,则比较容易进行资源共享.

优势好处体现在:

1.避免了单继承的局限性

2.增加了程序的拓展性,耦合度更低,实现解耦操作.

3.适合多个相同代码的线程共享同一个资源



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

线程安全问题产生的原理:多个线程共享同一个资源,同时执行同一个资源的数据,就会出现线程安全问题

三种:

1.同步代码块方式(重点)

2.同步方法(包含静态方法)

3.Lock锁



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

区别:

1.wait来源于Object类中的方法,sleep来源于Thread类中的方法

2.wait方法被调用时,会归还锁对象和释放CPU执行权.而sleep方法被调用时,只会释放CPU执行权

---

作者: LIUXIAOMING    时间: 2019-3-27 15:47
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答:继承Thread和实现Runnable接口两种。
   Thread的实现步骤：a.继承Thread类  b.重写run方法  c.创建子类对象  d.子类对象.start方法
   Runnable接口的实现步骤：a.实现Runnable接口  b.重写run方法  c.创建子类对象 d.创建Thread对象，new Thread（子类对象）  e.使用start方法开启线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：实现Runnable接口比继承Thread类所具有的优势：
    a.适合多个相同的程序代码的线程去共享同一个资源。
    b.可以避免java中的单继承的局限性。
    c.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
    d.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：多个线程在抢CPU时，抢到CPU的线程代码还没执行完，CPU又跑去执行另外一条线程，造成数据重复以及不存在的数据产生。
    当线程抢到资源要执行时，需要用锁锁住，让线程执行完再释放锁。
    有同步代码块，同步方法，和lock锁三种方式解决。
4.sleep()方法和wait()方法的区别？
答：sleep（）方法属于Thread类，会自动唤醒自己，代码执行完时不释放锁。
    wait（）方法属于Object类，需要notify方法进行唤醒，代码执行完后会释放锁。

---

作者: 小翔vvvv    时间: 2019-3-27 21:37
叶凌青
1.多线程的实现有几种方式？实现步骤分别是怎样的？
    (1)一种是继承Thread类方式
    步骤是:
    a. 创建一个Thread类的子类
    b. 在Thread类的子类中重写Thread类中的run方法,设置线程任务
    c. 创建Thread类的子类对象
    d. 调用Thread类中的方法start方法,开启新的线程,执行run方法

   (2)一种是实现Runnable接口方式
   步骤：
    a. 创建一个Runnable接口的实现类
    b. 在实现类中重写Runnable接口的run方法,设置线程任务
    c. 创建一个Runnable接口的实现类对象
    d. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    e. 调用Thread类中的start方法,开启新的线程执行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
     如果一个类继承Thread，则不适合资源 共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
     实现Runnable接口比继承Thread类所具有的优势：
(1) 适合多个相同的程序代码的线程去共享同一个资源。
(2) 可以避免java中的单继承的局限性。
(3) 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
(4）线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
前提：多个线程在执行同一资源并对资源进行数据的修改
产生的安全问题：a.线程修改数据，会产生重复的数据;b.线程会产生不存在的数据
解决方式：a.同步代码块
          b.同步方法
          c.Lock锁

4.sleep()方法和wait()方法的区别？
    sleep()方法使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
     wait()方法，无限期等待另一个线程执行一个特别的（唤醒）动作的线程
     sleep()方法源于Thread类让线程进入睡眠，指定了睡眠时间，时间一到自动苏醒。它进入到睡眠不会释放对象。
      wait()方法源于Object类，让线程进入等待，指定等待时间或者不指定知道其他线程唤醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

---

作者: 陈志铖    时间: 2019-3-30 21:59

陈志铖 发表于 2019-3-26 21:39
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式 创建继承Thread的子类      new Thread(借口R ...

同步代码块,同步方法,lock锁

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2