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.TCP和UDP协议的区别？
答：UDP 无连接通信，通信效率高，但是不能保证数据的完整性。
    TCP 面向连接，通信效率低，数据传输可靠无差错，每次连接都要经过“三次握手”的确认。


2.什么是三次握手？
答：三次握手指的是在TCP协议中，在发生数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
    第一次握手，客户端向服务器端发出连接请求，等待服务器确认；
    第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求；
    第三次握手，客户端再次向服务器端发送确认信息，确认连接。


3.网络编程三要素都是什么？
答：三要素是：IP地址、端口号、协议。


4.请描述一次文件上传的流程？
答：（1）开启服务端，并创建一个Socket对象，等待客户端连接；
    （2）在客户端中，创建一个Scoket对象和本地流FileInputStrem对象，使用本地流对象将需要上传的本地文件读写到客户端；
    （3）客户端请求连接服务端，并通过Scoket对象将文件传送给服务端；
    （4）服务端确认收到客户端连接，并将收到的文件通过FileInputStrem对象读取到服务端，并新建一个本地FileOutputStrem流对象将读取的文件写入到本地硬盘；
    （5）服务端向客户端发送一个“上传成功”的信号；
    （6）客户端接收到服务端的“上传成功”的信号，关闭客户端，释放资源。

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

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类是单继承，耦合性太高。实现Runnable解放了类继承位。
优势：将线程任务和线程对象分离，完成解耦，可以使用多个线程对象，执行一个线程任务
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
安全问题出现的条件
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
怎么解决：把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
三种方式：
同步代码块：synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
同步方法：就是把synchronized关键字加到方法上
同步静态方法：就是把synchronized关键字加到静态方法上
4.sleep()方法和wait()方法的区别？
sleep():是Thread类的方法，wait()是Object类的方法。
sleep调用之后会放弃cpu执行权，当不会放弃锁对象；wait()cpu执行权和锁对象都放弃
seelp到了时间自动苏醒，去抢夺CPU;wait需要线程唤醒方发唤醒自己。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
（1）
两种：方式1：继承Thread类实现
          方式2：实现Runnable接口实现
（2）
方式1：继承Thread类实现步骤
1.创建一个类继承Thread类
2.重写run方法
3.创建一个测试类，在测试类中创建继承类对象
4.对象调用stat方法启动线程

方式2：实现Runnable接口实现步骤
1.一个类实现Runnable接口
2.重写run方法
3.在测试类中创建实现类对象
4.创建线程对象Thread()，将实现类对象传递进去
5.对象调用stat方法启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：
（1）
一个是继承，一个是实现接口
（2）
不占用继承位
将线程任务和线程对象分离，进行解耦，可以实现多个线程共享同一资源
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
（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,重写Run方法
一种是实现Runnable接口重写Run方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread是继承位，Runnable是接口；实现Runnable接口会多出一个继承位
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
1有多线程，2有共享数据，3共同操作共享数据；给要执行的代码上锁同一时间只让一个线程进行操作，同步代码块，同步方法，静态同步方法
4.sleep()方法和wait()方法的区别？
sleep是暂时放弃cpu执行权，wait是需要被唤醒才会继续抢夺cpu执行权

1.多线程的实现有几种方式？实现步骤分别是怎样的？
分别有两种。
a.继承Thread类:1.编写一个类继承Thread类；2.重写run()方法(不是必要的);3.在测试类中创建线程对象；4.调用start()方法开启线程。
b.实现Runnable接口：1.编写类继承Runnable接口;2.重写run()方法（强制）；3.在测试类中创建线程任务对象；
4.创建Thread()对象，将线程任务对象作为参数传递进来，5.调用start()方法开启线程.

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
a.继承Thread类的run()方法不是必要的；实现Runnable接口的run()方法必须重写。
b.继承Thread类在测试类中创建线程对象，实现Runnable接口在测试类中先创建线程任务对象，然后在创建线程对象将任务对象传递进去。
c.继承Thread类程序耦合性较高，实现Runnable接口耦合度较低。
实现Runnable接口的优势体现：1.将线程任务和线程对象分离，进行解耦。可以实现多个线程共享同一资源
2.不占用继承位

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多线程操作执行统一资源，并进行写操作的时候。
解决方式：a.同步代码块：锁对象是任意对象，但必须保证多个现成的锁对象是同一个
b.同步方法：1.普通同步方法->对象是this    2.静态同步方法->对象是类名.class
c.lock/unlock锁：手动的开启锁和释放锁，释放锁必须写作finally代码块中。

4.sleep()方法和wait()方法的区别？
区别：a.sleep()方法是Thread类的方法，wait()方法Object类中的方法。
b.sleep()方法调用后会放弃CPU的执行权，但不会放弃锁对象；wait()方法调用后会放弃CPU的执行权和锁对象。
c.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类；
步骤：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()是Thread类的方法，wait()是Object类的方法。
sleep()方法是等带睡眠时间结束后自动苏醒。wait()方法是一定要有线程的唤醒，不然就不会醒。
sleep()方法只是去CPU的执行权，锁不会丢失。wait()方法是CPU的执行权和锁都丢失。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种实现的方式
第一种：①定义一个类MyThread继承Thread类
-
              ②在MyThread类中重写run()方法
-
              ③创建MyThread类的对象
-
              ④启动线程

第二种：①定义一个类MyRunnable实现Runnable接口
-
              ②在MyRunnable类中重写run()方法

              ③创建MyRunnable类的对象

              ④创建Thread类的对象，把MyRunnable对象作为构造方法的参数

              ⑤启动线程


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

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
产生原因：线程执行的随机性导致的；
方式：①同步代码块：锁对象是任意对象，但是必须保证多个线程锁对象是同一个
          ②同步方法
        普通同步方法
                锁对象是this
        静态同步方法
                类名.class
          ③lock锁
        手动的开启锁和释放锁，释放锁需要写在finally代码块中

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（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。

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类
定义一个类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.多线程的实现有几种方式？实现步骤分别是怎样的？

答：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()方法强制重写
优势：（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（）方法是导致当前线程等待，直到另一个线程调用，才会继续执行。