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

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：继承Thread类和实现Runnable接口两种方式;
        继承Thread类:
                1.编写一个类MyThread继承Thread类
                2.在该类中重写run()方法
                3.在测试类中创建线程MyThread对象
                4.线程对象调用start方法开启线程
        实现Runnable接口：
                1.定义一个类MyRunnable实现Runnable接口
                2.重写run方法（强制）
                3.在测试类中创建MyRunnable类的对象
                4.创建Thread类的对象，把MyRunnable对象作为构造方法的参数
                5.调用start方法开启线程
        一般优先使用Runnable接口方式去实现多线程，
        因为Runnable接口能将线程任务和线程对象分离，进行解耦。
                还可以实现多个线程共享同一资源，还不占用继承位。
               
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
        区别：一个是继承，一个是实现接口
        优势：1.避免了Java单继承的局限性
                  2.适合多个相同程序的代码去处理同一个资源的情况，
                        把线程和程序的代码、数据有效分离，较好的体现
                        了面向对象的设计思想       

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：产生原因：1.是多线程环境
                          2.有共享数据
                          3.有多条语句操作共享数据
        解决安全问题：
                          把多条语句操作共享数据的代码给锁起来，
                          让任意时刻只能有一个线程执行即可。
        解决安全方案：
                          1.同步代码块
                                    同步代码块格式：
                                                synchronized(任意对象) {
                                                        多条语句操作共享数据的代码
                                                }
                                               
                                        锁对象是任意对象，但是必须保证多个线程锁对象是同一个。                                       
                                        好处：解决了多线程的数据安全问题
                                        弊端：当线程很多时，因为每个线程都会去判断同步上的锁，
                                                  这是很耗费资源的，无形中会降低程序运行效率
                          2.同步方法
                                        就是把synchronized关键字加到方法上
                                        格式：
                                                修饰符 synchronized 返回值类型 方法名(方法参数) {
                                                                方法体；
                                                }
                                        普通同步方法锁对象是this
                                        静态同步方法锁对象是类名.class               
                          3.lock锁
                                        手动的开启锁和释放锁，释放锁需要写在finally代码块中
                                       

4.sleep()方法和wait()方法的区别？
答：
        区别：
                1.sleep方法是Thread类的
                  wait方法是Object类的
                2.sleep调用之后会放弃CPU执行权，但是不会放弃锁对象
                  Wait调用之后CPU执行权和锁对象都会放弃
                3.sleep方法到了时间自动苏醒，会去抢夺CPU执行权
                  wait方法没有线程唤醒不会自动苏醒       

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

继承Thread类,然后重写run方法,然后使用start方法.

实现runnable接口,

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

1.将线程任务和线程对象分离，进行解耦。可以实现多个线程共享同一资源

2.不占用继承位

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

当多线程操作同一资源，并执行写操作的时候,会发生线程不同步引发的问题

1.同步代码块

- - 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
  - Java提供了同步代码块的方式来解决
- 同步代码块格式：
      synchronized(任意对象) {
              多条语句操作共享数据的代码
      }
  synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

2.同步方法

- 同步方法的格式
  同步方法：就是把synchronized关键字加到方法上
      修饰符 synchronized 返回值类型 方法名(方法参数) {
              方法体；
      }
  同步方法的锁对象是什么呢?
          this
- 静态同步方法
  同步静态方法：就是把synchronized关键字加到静态方法上
      修饰符 static synchronized 返回值类型 方法名(方法参数) {
              方法体；
      }
  

3.lock锁

- ReentrantLock构造方法创建lock锁实例
    方法名                    说明                  
    ReentrantLock()        创建一个ReentrantLock的实例
- 加锁解锁方法
    方法名                  说明  
    void lock()          获得锁
    void unlock()        释放锁

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

sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。

sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃

sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1：定义：继承Thread类
定义一个类Mythread继承Thread类
在MyThread类中重写run()方法
创建MyThread类的对象
2：实现Runnable接口
定义一个类 MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1：避免了JAVA单继承的局限性
继承只能继承一次，实现可以实现多次
继承，一般用于共性的抽取
使用继承Thread类的方式，占用继承位
2：这个线程对象类，做了两件事情
本身就是一个线程对象，用于开始线程
在类中，又定义线程任务
耦合度很高，我们希望将线程对象和线程任务分开
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码，数据有效分离，较好的体现了面向对象的设计思想
可以使用多个线程对象，执行一个线程任务

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享同一个资源，并执行写操作的时候，会产生线程安全问题。要解决线程安全问题，就要破坏掉线程安全环境。
同步代码块，同步方法，Lock锁和线程安全类

4.sleep()方法和wait()方法的区别？
sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃
sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
有两种；
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
实现Runnable接口的优势：1、不占用继承位  2、解耦。将线程对象和线程任务分开

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
多个线程执行共同的资源，并进行写操作
可以使用同步代码块(锁是任意对象，但是要保证使用的是同一个对象)、同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
答：
sleep()方法是等带睡眠时间结束后自动苏醒。wait()方法是一定要有线程的唤醒，不然就不会醒。
sleep()方法只是去CPU的执行权，锁不会丢失。wait()方法是CPU的执行权和锁都丢失。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式: 1.继承Thread类   2.实现Runnable接口

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1.将线程任务和线程对象分离，进行解耦。可以实现多个线程共享同一资源  2.不占用继承位

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生:当多线程操作同一资源，并执行写操作的时候
解决方法:1.同步代码块  2.同步方法  3.lock锁

4.sleep()方法和wait()方法的区别？
sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答 ;  两种,分别是继承Thread类和实现Runnable接口

继承Thread类;
        1. 定义一个MyRunnable类 继承Thread类               
        2.重写run()方法                       
        3.创建MyRunnable类对象                       
        4.启动线程                               

实现Runnable接口
        1.定义一个MyRunnable类实现Runnable接口
        2.重写run()方法
        3.创建MyRunnable类对象
        4.创建Thread类的对象,把MyRunnable对象作为构造方法的参数
        5.启动线程


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答:          1.避免了JAVA单继承的局限性 , 解放了继承位
        2.适合多个相同的程序代码去处理同一个资源的情况 , 把线程和程序的代码  数据有限的分离, 较好的体现了面向对象的设计思想
        3.将线程任务和线程对象分离

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答:        是由是否是多线程环境 , 是否有共享数据 ,  是否有多条语句操作共享数据来决定是否有线程安全问题
        可以通过同步代码块, 同步方法,Lock锁来解决线程安全问题       

4.sleep()方法和wait()方法的区别？
答:
        1.sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。
        2.sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃
        3.sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式:继承Thread类和实现Runnable接口;
继承Thread类步骤:
- 继承Thread
- 重写run()
- 创建线程对象
- 调用start()
实现Runnable接口步骤;
- 实现Runnable
- 重写run()
- 创建接口实现类对象
- 创建线程对象(new Thread())
- 调用start()

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类可以不重写run(),而实现Runnable必须重写;
实现Runnable接口的优势:
- 避免了Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想


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

:
- 是多线程环境

- 有共享数据

- 有多条语句操作共享数据

如何解决多线程安全问题


- 基本思想：让程序没有安全问题的环境

- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

有哪几种方式
- 同步代码块的方式来解决

- 同步方法的方式来解决
- Lock锁的方式来解决

4.sleep()方法和wait()方法的区别？
- sleep()是Thread类的方法,wait()是Object类的方法;
- sleep()调用之后会放弃cpu执行权,但是不会放弃锁对象;wait()方法调用后cpu执行权和锁对象都放弃;
- sleep()方法使线程进入阻塞状态一段时间,时间结束后线程会自动回到就绪状态;wait()方法使线程进入阻塞,需要手动使线程回到就绪状态,否则线程会一直处于阻塞状态.

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
优势：（1）避免了Java单继承的局限性
          （2）适合多个相同程序的代码取处理同一个资源的情况，把线程和程序的代码
                   数据有效分离，较好的体现了面对对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：（1）是多线程环境（2）有共享数据（3）有多条语句操作共享数据
解决：让程序没有安全问题的环境
         （1）用同步代码块解决（2）同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
   sleep（）方法是使当前正在执行的线程停留（暂时停留）指定的毫秒数，而
   wait（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
优势：（1）避免了Java单继承的局限性
          （2）适合多个相同程序的代码取处理同一个资源的情况，把线程和程序的代码
                   数据有效分离，较好的体现了面对对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：（1）是多线程环境（2）有共享数据（3）有多条语句操作共享数据
解决：让程序没有安全问题的环境
         （1）用同步代码块解决（2）同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
   sleep（）方法是使当前正在执行的线程停留（暂时停留）指定的毫秒数，而
   wait（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。

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

答：2种。
       第一种是继承Thread类，4个步骤：
       （1）定义一个类MyThread继承Thread类
       （2）类中重写run()方法（不是强制的）
       （3）在测试类中创建类MyThread的线程对象
       （4）调用start()方法启动线程
       另一种是实现Runnable接口，5个步骤：
       （1）定义一个类MyThread实现Runnable接口
       （2）类中重写run()方法（是强制的）
       （3）在测试类中创建类MyThread的任务对象
       （4）创建Thread线程对象，把MyThread的任务对象传递进去
       （5）调用start()方法启动线程


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

答：区别在于继承Thread类的线程对象和线程任务是同一个，不强制重写run()方法；
                    实现Runnable接口的线程对象和线程任务不是同一个，必须重写run()方法。
       实现Runnable接口的优势体现在：
       （1）将线程任务和线程对象分离，进行解耦。可以实现多个线程共享同一资源。
       （2）不占用继承位。

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

答：当多个线程共享同一个资源，并执行写操作的时候，会产生线程安全问题。
       要解决线程安全问题，就要破坏掉线程安全环境，有三种方式：
       （1）同步代码块
       （2）同步方法，分为普通同步方法和静态同步方法
       （3）Lock锁

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

答：sleep()和wait()都是线程阻塞方法，sleep()是Thread类的方法，wait()是Object类的方法。
       sleep()调用之后会放弃CPU执行权，但是不会放弃锁对象；wait()调用之后是CPU执行权和锁对象都放弃。
       sleep()到了时间自动苏醒，去抢夺CPU执行权；wait()没有线程唤醒不会自己醒。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
        两种方式。
        第一种是继承Thread类。①类继承Thread类，②并重写Run方法，③在main方法内创建类对象，④该对象调用.start()方法。
        第二种是实现Runnable接口。①类实现Runnable接口，②并重写Run方法，③在main方法内创建类对象，④将该对象作为引用参数创建Thread类的对象，⑤Thread类的对象调用.start()方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类是通过类对象启动多线程，实现Runnable接口是通过Thread类的对象启动多线程。
        实现Runnable接口的优势：避免了Java单继承的局限性，降低程序代码的之间的耦合度。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        在多线程环境，有共享数据，且有多条语句操作共享数据时，会出现线程安全问题。
        解决线程安全问题，有2种方式。第一种是同步代码块Synchronized锁定操作共享数据的多条语句，让任意时刻只能有一个线程执行；第二种是通过Lock锁锁定操作共享数据的多条语句，让任意时刻只能有一个线程执行。

4.sleep()方法和wait()方法的区别？
        sleep()方法可以指定休眠时间进行休眠，时间过后自动恢复就绪状态，准备抢占CPU，wait()方法一般和notify()方法或notifyAll()方法配合使用，调用wait()方法则进入休眠，直到调用notify()方法或notifyAll()方法时才解除休眠状态；
        sleep()方法调用之后放弃CPU抢夺权，不放弃锁对象，wait()方法调用之后放弃CPU抢夺权和锁对象。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答 ;  两种,分别是继承Thread类和实现Runnable接口

继承Thread类;
        1. 定义一个MyRunnable类 继承Thread类               
        2.重写run()方法                       
        3.创建MyRunnable类对象                       
        4.启动线程                               

实现Runnable接口
        1.定义一个MyRunnable类实现Runnable接口
        2.重写run()方法
        3.创建MyRunnable类对象
        4.创建Thread类的对象,把MyRunnable对象作为构造方法的参数
        5.启动线程


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答:          1.避免了JAVA单继承的局限性 , 解放了继承位
        2.适合多个相同的程序代码去处理同一个资源的情况 , 把线程和程序的代码  数据有限的分离, 较好的体现了面向对象的设计思想
        3.将线程任务和线程对象分离

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答:        是由是否是多线程环境 , 是否有共享数据 ,  是否有多条语句操作共享数据来决定是否有线程安全问题
        可以通过同步代码块, 同步方法,Lock锁来解决线程安全问题       

4.sleep()方法和wait()方法的区别？
答:
        1.sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。
        2.sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃
        3.sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
优势：（1）避免了Java单继承的局限性
          （2）适合多个相同程序的代码取处理同一个资源的情况，把线程和程序的代码
                   数据有效分离，较好的体现了面对对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：（1）是多线程环境（2）有共享数据（3）有多条语句操作共享数据
解决：让程序没有安全问题的环境
         （1）用同步代码块解决（2）同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
   sleep（）方法是使当前正在执行的线程停留（暂时停留）指定的毫秒数，而
   wait（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
优势：（1）避免了Java单继承的局限性
          （2）适合多个相同程序的代码取处理同一个资源的情况，把线程和程序的代码
                   数据有效分离，较好的体现了面对对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：（1）是多线程环境（2）有共享数据（3）有多条语句操作共享数据
解决：让程序没有安全问题的环境
         （1）用同步代码块解决（2）同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
   sleep（）方法是使当前正在执行的线程停留（暂时停留）指定的毫秒数，而
   wait（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。

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

答：2种。
       第一种是继承Thread类，4个步骤：
       （1）定义一个类MyThread继承Thread类
       （2）类中重写run()方法（不是强制的）
       （3）在测试类中创建类MyThread的线程对象
       （4）调用start()方法启动线程
       另一种是实现Runnable接口，5个步骤：
       （1）定义一个类MyThread实现Runnable接口
       （2）类中重写run()方法（是强制的）
       （3）在测试类中创建类MyThread的任务对象
       （4）创建Thread线程对象，把MyThread的任务对象传递进去
       （5）调用start()方法启动线程


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

答：区别在于继承Thread类的线程对象和线程任务是同一个，不强制重写run()方法；
                    实现Runnable接口的线程对象和线程任务不是同一个，必须重写run()方法。
       实现Runnable接口的优势体现在：
       （1）将线程任务和线程对象分离，进行解耦。可以实现多个线程共享同一资源。
       （2）不占用继承位。

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

答：当多个线程共享同一个资源，并执行写操作的时候，会产生线程安全问题。
       要解决线程安全问题，就要破坏掉线程安全环境，有三种方式：
       （1）同步代码块
       （2）同步方法，分为普通同步方法和静态同步方法
       （3）Lock锁

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

答：sleep()和wait()都是线程阻塞方法，sleep()是Thread类的方法，wait()是Object类的方法。
       sleep()调用之后会放弃CPU执行权，但是不会放弃锁对象；wait()调用之后是CPU执行权和锁对象都放弃。
       sleep()到了时间自动苏醒，去抢夺CPU执行权；wait()没有线程唤醒不会自己醒。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
有两种；
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
实现Runnable接口的优势：1、不占用继承位  2、解耦。将线程对象和线程任务分开

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
多个线程执行共同的资源，并进行写操作
可以使用同步代码块(锁是任意对象，但是要保证使用的是同一个对象)、同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
答：
sleep()方法是等带睡眠时间结束后自动苏醒。wait()方法是一定要有线程的唤醒，不然就不会醒。
sleep()方法只是去CPU的执行权，锁不会丢失。wait()方法是CPU的执行权和锁都丢失。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1：定义：继承Thread类
定义一个类Mythread继承Thread类
在MyThread类中重写run()方法
创建MyThread类的对象
2：实现Runnable接口
定义一个类 MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1：避免了JAVA单继承的局限性
继承只能继承一次，实现可以实现多次
继承，一般用于共性的抽取
使用继承Thread类的方式，占用继承位
2：这个线程对象类，做了两件事情
本身就是一个线程对象，用于开始线程
在类中，又定义线程任务
耦合度很高，我们希望将线程对象和线程任务分开
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码，数据有效分离，较好的体现了面向对象的设计思想
可以使用多个线程对象，执行一个线程任务

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享同一个资源，并执行写操作的时候，会产生线程安全问题。要解决线程安全问题，就要破坏掉线程安全环境。
同步代码块，同步方法，Lock锁和线程安全类

4.sleep()方法和wait()方法的区别？
sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃
sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
优势：（1）避免了Java单继承的局限性
          （2）适合多个相同程序的代码取处理同一个资源的情况，把线程和程序的代码
                   数据有效分离，较好的体现了面对对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：（1）是多线程环境（2）有共享数据（3）有多条语句操作共享数据
解决：让程序没有安全问题的环境
         （1）用同步代码块解决（2）同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
   sleep（）方法是使当前正在执行的线程停留（暂时停留）指定的毫秒数，而
   wait（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1、继承Thread类；
步骤：1、继承Thread类 2、重写run() 方法 3、创建继承Thread类的子类 4、调用start()方法启动线程
2、实现Runnable接口；
步骤：1、实现Runnable接口 2、重写run() 方法 3、创建线程任务对象 4、创建Thread对象将线程任务传递进去 5、调用start() 方法 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        继承Thread类的run()方法不强制重写。实现Runnable接口的run()方法强制重写
优势：（1）避免了Java单继承的局限性
          （2）适合多个相同程序的代码取处理同一个资源的情况，把线程和程序的代码
                   数据有效分离，较好的体现了面对对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生：（1）是多线程环境（2）有共享数据（3）有多条语句操作共享数据
解决：让程序没有安全问题的环境
         （1）用同步代码块解决（2）同步方法(锁是this，静态方法的锁是类.class)、Lock锁，三种方式来解决

4.sleep()方法和wait()方法的区别？
   sleep（）方法是使当前正在执行的线程停留（暂时停留）指定的毫秒数，而
   wait（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。