1.多线程的实现有几种方式？实现步骤分别是怎样的？
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？

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()方法后本线程才进入对象锁定池准备

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执行权，不会释放锁对象

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执行权

李伟斌

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方法进行唤醒，代码执行完后会释放锁。

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和锁

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

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() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待

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执行权；

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()方法才能唤醒，继续活动

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和同步锁锁。

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执行权

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执行权。

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执行权。

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()方法后本线程才进入对象锁定池准备

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执行权，还会释放锁对象。

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()休眠期间会归还锁

王佳盛
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执行权

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执行权

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执行权。