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方法来唤醒，否则就一直无限等待。

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

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和锁，需要唤醒。

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

陈鹏涛
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类
                 唤醒的线程将无法继续，直到当前线程释放该对象上的锁。
                可以理解为多个线程之间的协作关系， 多个线程会争取锁，同时相互之间又存在协作关系。
           
   

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执行权和锁对象。

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唤醒。

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等待被调用唤醒。

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

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

有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唤醒。

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类

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方法来唤醒，否则就一直无限等待。

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占用权和锁的执行权

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

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

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唤醒。

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()方法

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资源或者让当前线程停止执行一段时间，但不会释放锁。

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