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

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

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

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

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

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式,分别为通过继承Thread类和实现Runnable接口;
(1)通过继承Thread类的实现步骤分为:
a.定义Thread的子类,并且重写run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体;
b.创建Thread子类对象,也就是线程对象;
c.通过调用线程对象的start()方法来开启子线程,执行run()中的方法体.
(2)通过实现Runnable接口的实现步骤分为:
a. 定义Runnable接口的实现类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体;
b.创建Runnable实现类的实例,并以此以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象;
c.调用线程对象的start()方法来启动线程.                       

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
a.使用继承的方式,占用继承位;使用实现的方式,不占用继承位置,而是占用一个接口位置;
b.使用继承的方式,耦合度太高,两个功能写在一起;使用实现的方式,两个功能拆开,解耦合;
c.使用继承的方式,不能实现资源共享;使用实现的方式,可以实现资源共享;

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享同一个资源,并对这个资源中的数据执行写操作,就会产生线程安全问题,出现不该出现的数据,或是一个数据被同时使用,造成错误.
解决线程安全问题,有三种方式:
a.使用同步代码块,格式为synchronized(同步锁){需要操作的代码}   多个线程要想实现同步技术,必须使用同一个锁对象,锁对象可以是任意对象;
原理是拿到锁的线程不执行完不会释放锁,没有锁的线程进不来
b.使用同步方法 格式为public synchronized void method(){可能会产生线程安全问题的代码} 注意:静态同步方法使用的锁对象是类名.class
c.使用Lock解决,格式为Lock lock = new ReentrantLock();      public void lock();加同步锁{需要加同步的代码}   public void unlock();
释放同步锁;一般会在finally中释放锁,保证资源不被浪费;

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

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类
（1）定义一个类继承Thread；
（2）重写Thread子类中的run( )方法，设置线程任务；
（3）在测试类中创建Thread子类对象；
（4）通过子类对象调用star( )方法，开启新线程
实现Runnable接口
（1）创建一个类实现Runnable接口；
（2）重写实现类中的run( )方法，设置线程任务；
（3）在测试类中创建实现类对象；
（4）在测试类中创建Thread对象，并将实现类对象作为参数传入Thread对象构造方法中；
（5）通过Thread对象调用star( )方法，开启新线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）避免了单继承的局限性。继承Thread类占用继承位，实现Runnable接口，可以实现其他接口、继承其他类；
（2）增强了程序的扩展性，降低了耦合性。继承Thread类耦合度太高，两个功能写在一起，实现Runnable接口将设置线程任务和开启新线程分离开，解耦合
（3）使用继承的方式，不能实现资源共享；使用实现的方式，可以实现资源共享

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程共享同一个资源并对这个资源中的数据进行写操作时会产生线程安全问题。
同步代码块
synchronized(同步锁){ 需要同步操作的代码 }   
1.多个线程要想实现同步技术，必须使用同一个锁对象
2.锁对象可以是任意对象
原理：拿到锁的线程不执行完不会释放锁，没有锁的线程进不来
同步方法
public synchronized void method(){ 可能会产生线程安全问题的代码 }   
1.普通同步方法
锁对象：this
2.静态同步方法
锁对象：类名.class
Lock锁
Lock lock = new ReentrantLock();   
public void lock() :加同步锁
{需要加同步的代码}
public void unlock() :释放同步锁   

4.sleep()方法和wait()方法的区别？
Sleep方法是        Thread类中的方法
调用sleep方法，可以让线程休眠指定的时间，世家女到了以后，继续抢夺CPU执行权
sleep方法不会释放锁对象
Wait方法是Object类中的方法
调用Wait方法，会让线程无限等待，一直到另一 条和该线程有相同的锁对象的线程调用notify()方法，将他唤醒
Wait方法会释放锁对象

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式，第一种继承Thread类方式创建多线程：（1）定义一个Thread类的子类。（2）在子类中重写Thread类的run（）方法,设置线程任务。（2）在测试类中创建Thread类的子类对象。（3）调用Thread类中的start（）方法,开启新的线程执行run（）方法。第二种实现接口方式创建多线程：（1）定义一个Runnable接口的实现类 （2）在实现类中重写Runnable接口的run（）方法,设置线程任务 （3）在测试类中创建一个Runnable接口的实现类对象（4）创建Thread类对象,构造方法中传递Runnable接口的实现类对象（5）调用Thread类中的start（）方法,开启新的线程执行run（）方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：
（1）使用继承的方式，占用继承位；使用实现的方式，不占用继承位，而是占用的一个接口位置
（2）使用继承的方式，耦合度太高，将线程任务和线程对象绑定在一起；使用实现的方式，线程任务和线程对象拆开，解耦合
（3）使用继承的方式，不能实现资源共享；使用实现的方式，可以实现资源共享
好处：
（1）避免java中的单继承的局限性
（2）将线程任务和线程对象，进行分离，增加程序的健壮性，实现解耦操作
（3）适合多个相同的程序代码的线程去共享同一个资源（线程任务）。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享同一个资源，并对这个资源中的数据执行写操作，就会产生线程安全问题。
解决安全问题有三种方式：第一种同步代码块：（1）格式：synchronized(同步锁){ 需要同步操作的代码 } （2）多个线程要想实现同步技术，必须使用同一个锁对象（3）锁对象可以是任意对象  ps：原理：拿到锁的线程不执行完不会释放锁，没有锁的线程进不来
第二种同步方法（1）public synchronized void method(){ 可能会产生线程安全问题的代码 } （2）普通同步方法，锁对象：this（3）静态同步方法，锁对象：类名.class
第三种Lock锁方式Lock lock = new ReentrantLock(); public void lock() ;加同步锁{需要加同步的代码}public void unlock() ;释放同步锁

4.sleep()方法和wait()方法的区别？
（1）Sleep方法是 Thread类中的方法；Wait方法是 来源于Object类中的方法
（2）调用sleep方法，可以让线程休眠指定的时间，时间到了以后，继续抢夺CPU执行权，sleep方法不会释放锁对象；调用Wait方法，会让线程无限等待，一直到另一条和该线程有相同的锁对象的线程调用notify()方法，将他唤醒，wait方法会释放锁对象

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式。继承以及实现接口
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
使用继承的方式，占用继承位；使用实现的方式，不占用继承位，而是占用的一个接口位置


使用继承的方式，耦合度太高，两个功能写在一起；使用实现的方式，两个功能拆开，解耦合


使用继承的方式，不能实现资源共享；使用实现的方式，可以实现资源共享

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程之间共享同样的资源，并对其资源中的数据执行以及操作。同步代码块方法以及Lock锁方法。同步方法
4.sleep()方法和wait()方法的区别？
sleep()无法释放锁对象，wait()方法可以用notify()方法来唤醒，会释放锁对象

1.多线程的实现有几种方式？实现步骤分别是怎样的？
         第一种：创建thread的子类，类中重写run方法，创建子类对象，通过对象名调用start方法。
         第二种：创建runnable接口的实现类，实现类中重写run方法，创建实现类对象，创建thread对象使用有参构造传入实现类对象，再使用tjread对象名调用start方法。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
      继承Thread类，无法再继承其他类，run方法只能写在子类中。
      实现Runnable接口，可以实现多继承，run方法可以写在多个子类中。也可以通过匿名内部类写在测试类中。 它的优势在于可以让多任务代码和开启新线程进行分离，可以实现代码对多个线程任务进行共享调用和启动线程。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
     多个线程同时运行时，对共享的run方法进行了调用和执行，当多线程运行后的结果跟单线程运行后的结果有存在差异性，就代表产生了线程安全问题。
       第一种：同步代码块
                      创建 object 的同步锁对象
                      synchorinized（同步锁对象){需要实现同步的方法体}
       第二种：同步方法
                       synchorinized（类名.Class控制){需要实现同步的方法体}
                  run中调用此方法
      第三种：锁机制
                     创建lock对象
                      对象.lock     方法体    对象.unlock
4.sleep()方法和wait()方法的区别？
     sleep()方法是设置线程暂停睡眠的等待时间，相当于暂停执行，等时间倒计结束后，恢复执行。
      wait()方法通常用在两个线程任务之间的通讯上。当其中一个线程使用某对象调用了Object.wait方法，那么此线程就交出执行权处于等待状态，等待另一个线程中使用那个对象调用了Object.notify方法，执行权才归还到wait方法那，恢复执行wait后边的代码。并且可以达到循环呼应的效果。

1.多线程的实现有几种方式？实现步骤分别是怎样的？使用继承类的方式实现，创建一个类继承Thread类，重写run（）方法，在测试类中创建子类对象，调用.start()方法。
使用实现类的方式实现，定义一个类，实现runnable接口 ，重写run（）方法，在测试类中创建实现类对象，创建线程对象Thread。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类占用继承位，耦合度高，不能实现资源共享
实现Runnable接口不占用继承位，只占用一个接口位置，功能拆开解耦合，可以实现资源共享。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程共享一个资源时，并对这个资源的数据进行写入操作时，会产生线程安全问题。
解决线程安全问题的方式有：同步代码块，同步方法和同步锁。
4.sleep()方法和wait()方法的区别？
sleep（）只是暂停一段指定的时间，而wait（）是无限等待，直到另一条线程调用notify（）方法唤醒它为止。

1.多线程的实现有几种方式？实现步骤分别是怎样的？ 答：多线程实现总共有两种方式，   1.一种是继承Thread类实现run（）方法，在run方法，然后在测试类里面创建继承了Thread类的子类对象，通过对象调用start方法启动线程。   2.另一种是实现Runnable接口，重写run方法在方法 在测试类里面创建实现了Runnable接口的实现类，在创建Thread类对象，把实现了Runnable接口的实现类的对象通过构造方法传进Thread的构造方法，然后用Thread对象调用start方法启动线程 2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？ 1.继承的缺点有占用继承位，耦合度高，不能实现资源共享，实现的方式可以解决以上问题 2.实现的优势有以下几点， 1.可以实现资源共享 2.降低耦合度 3.不占用继承位置 3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？ 答：1.当多个线程同时访问一份共享数据的时候会出现线程安全问题，        2.可以使用同步代码块来解决线程安全问题，        2.总共有同步代码块，普通同步方法锁，静态方法锁，        3.同步代码块的锁对象可以是任意对象        4.普通方法同步锁的对象是this本身        5.静态方法锁的锁对象是 类名.class以反射的形式拿到本身的对象实例 4.sleep()方法和wait()方法的区别？ 答：sleep方法可以接收一个毫秒值，可以设置休眠指定的时间，时候过后会自己醒过来，sleep方法来自Thread类中        wait()方法为无限休眠，调用了此方法后，会让线程无限等待必须由另一线程唤醒 才能激活此线程 唤醒后会释放锁对象 wait方法来自Object中 必须由锁对象调用

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种
一种：创建一个子类继承Thread，重写run()方法即可，创建对象后使用start()调用；
二种：创建一个runnabe接口，重新run（），创建运行类似先创建接口，还要new一个Thread即可；
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：顾名思义继承Thread就是继承类，重写run()方法即可，创建对象后使用start()调用； 而实现Runnable就是一个接口，创建运行类似先创建接口，还要new一个Thread即可；
因为继承只能单继承不可多继承只能继承一个父类，而接口呢！是可以多个创建实现多线程也方便，所以runnable接口更有优势。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：当多个线程共享一份数据，并试图对该数据进行修改时容易产生线程安全问题，即不同线程的执行顺序将产生不同的结果。
三种方式解决安全问题！
1，修饰符   synchronized 2，静态同步方法 static synchronized  3，Lock锁
4.sleep()方法和wait()方法的区别？
答：sleep是在短时间睡眠可自醒；
wait是永久性睡眠，需要有人来叫醒，不然不会醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？ 答：多线程有两种实现方式，继承Thead类和实现Runnable接口。 继承Thead类：创建一个Thead的子类，需要重写run（）方法，自定义线程的执行内容，再new一个线程对象通过.star（）来启动。 实现Runnable接口：创建一个Runnable的实现类，重写run（）方法，自定义线程的执行内容，再创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。 最后通过.star（）来启动。 2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？ 答：如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。实现Runnable接口方便多个线程的资源共享，避免java中的单继承的局限性，降低耦合性。 3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？ 答：如果有多个线程在同时访问同一资源的时候，且多个线程中对资源有写的操作，这时候就容易出现线程安全问题。有三种方法解决线程安全问题，同步代码块，同步方法，锁机制。 同步代码块：synchonized（同步锁），synchonized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问，同步锁只是一个概念,可以想象为在对象上标记了一个锁，锁对象可以是任意类型，多个线程对象需要使用同一把锁。 同步方法：使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。 Lock锁机制：Lock锁机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，包括lock.lock（）加同步锁，lock.unlock（）释放同步锁。 4.sleep()方法和wait()方法的区别？ 答：sleep（）方法是让程序休眠指定时间，然后继续运行。而wait（）方法将进入无限睡眠，如果没有notify方法唤醒就不会恢复运行。

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外 等着

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁. 1. 锁对象 可以是任意类型。 2. 多个线程对象  要使用同一把锁。

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。 Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。 public void unlock() :释放同步锁。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
        继承Thread类方式
                创建一个子类直接继承Thread,
                重写run方法
                在测试类中创建子类对象,调用start()方法
        实现Runnable接口方式
                1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
                2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
                3. 调用线程对象的start()方法来启动线程。


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


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        当多线程访问共享数据并执行写操作时，就会发生线程安全问题；
        解决线程问题有三种方式：
        方案一：同步代码块（锁对象为任意对象   obj）
        方案二：同步方法（锁对象是实现类本身，也就是this）
        方案三：静态方法（锁对象是本类的class对象--RunnableImpl.class）
4.sleep()方法和wait()方法的区别？
        sleep()参数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。而wait（）无参方法将进入无限睡眠，如果没有notify方法唤醒就不会恢复运行wait()数列表输入long值，代表毫秒值，在休眠指定毫秒后将自动恢复运行。不过可以提前被notify 唤

1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式：
        Thread：普通类继承Thread类，重写run方法，在主方法内创建Thread对象，然后用对象名点start()
方法，开启子线程。
Runnable：普通类实现Runnable类，重写run方法，在主方法内创建普通类对象，在创建Thread对象
        使用Thread类构造器调用普通类对象名。然后调用start()方法，开启子线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread类：霸占的继承他的子类继承位，让我们要使用子类特有方法时，而用不了。
Thread类偶和高
无法对线程对象和资源分离，所以不能使用线程对资源共享。
Runnable接口：降低的单继承的局限性，
增强的程序扩展，
可以资源共享
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程同时共享一个数据，就会就会产生数据相同，数据跳出等，安全问题。
        1.用同步代码块。
2.用同步方法
3.静态同步方法
4lock锁
4.sleep()方法和wait()方法的区别？
Sleep（）方法：是睡眠线程，只要线程醒了，就会继续执行程序。
Wait（）方法：是冻结线程，用notifg'方法和notifgAll方法解冻。

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

两种.
（1）通过继承类。创建一个继承Thread类的子类-->重写run()方法-->在测试类中建立子类的对象，调用start()方法。
（2）通过接口。创建一个Runnable接口的实现类-->重写run()方法-->在测试类中建立实现类的对象
     -->把实现类的对象作为参数建立Thread的对象，调用start()方法。

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

优势：（1）不占用继承位，因为只能单继承，省出继承位可以用来实现其他的功能。
（2）耦合性低，继承Thread类，把对象和功能内容放在一起。
（3）可以实现资源的共享。

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

原因：多个线程对同一个数据进行写操作。
解决方法有三种：
（1）同步代码块
（2）同步方法，this对象，静态同步方法
（3）锁机制Lock

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

区别：sleep()是时间到了就加入争取cup，休眠时同步锁不放给其他线程。
wait()只能等notify()方法才能解冻，冻结期间同步锁会放给其他线程。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread:
1,创建Thread的继承对象
2.重写run方法(方法要执行的内容)
3.创建一个自定义对象 (继承 Thread)
4.调用start()-->会自动调用run方法
实现Runnable:
1,创建Runnable的继承对象
2.重写run方法(方法要执行的内容)
3.创建一个自定义接口 (实现 Runnable)
4.创建一个Thread线程类-->runnable接口的有参构造进行创建对象
5.Thread线程类.start
==========================================
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1继承,占用继承位,实现方式,不占继承位,占用一个借口位置
2.实现继承的方法,耦合度抬高,两个功能写在一起,实现的方式,两个功能拆开,解耦合
3.继承的方式,不能实现资源共享, 实现的方式,可以实现资源共享.
================================================
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程访问了同一个资源,执行同一组的数据,执行了写操作,会产生线程安全问题
================================================
三种方法:
同步代码块,同步方法:
synchronized(锁对象){
可能会发现线程安全的代码(访问了共享的数据的代码)
}
1.通过代码块中的锁对象,可以使用任何对象
2,但是必须保证镀铬线程使用的锁对象是同一个
3,锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行
同步中的线程,没有执行完毕不会释放锁,同步外的线程没有锁进不去同步.
同步方法的锁对象是this
静态方法:静态方法的锁对象是本类的class属性-->class文件对象(反射)
lock锁:void lock()获取锁,void unlock ()释放锁
===============================================
4.sleep()方法和wait()方法的区别？
sleep()方法:Thread类中的方法:
调用sleep()方法,可以让线程休眠指定时间,时间到了,继续强占Cpu.
sleep方法不会释放锁对象
wait()方法: object类中的方法
该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，
必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
wait会释放锁对象

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现有2种方式，分别为使用创建Thread类的子类对象和实现Runnable接口的方式。
第一种 创建Thread类子类对象的实现方式：
1.创建一个子类继承Thread类。
2.在Thread类的子类中重写Thread类中的run方法，设置线程任务，这个任务指的是开启线程具体要做什么
3.在测试类中创建Thread类的子类对象
4.使用子类对象调用Thread类的方法start()方法，启动新的线程，开启线程任务
第二种方式：实现Runnable接口
1.创建一个实现类实现Runnable接口
2.重写Runnable接口的run()方法，设置线程任务，这个任务指的是开启线程具体要做什么
3.在测试类中创建实现类对象，创建一个Thread类的对象并在构造方法中传入Runnable接口的实现类对象
4.调用Thread类对象的方法starr()，启动新的线程，并执行Runnable实现类中的run()方法。


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：区别在于
1.继承Thread类是继承Thread类的，而java中是单继承的规则的，Thread占用了继承位，想使用继承的时候则没办法使用了。实现Runnable接口是实现runnable接口，java中是支持多实现接口的，这个时候这个实现类还可以去继承其他类和实现其他接口。
2.继承Thread类的对象和功能（线程任务）紧密的耦合在一起，无法对线程对象和资源做分离，每一个线程对象都有一个资源，所以无法使用线程对资源共享。而实现Runnable接口把设置线程任务和开启新线程分离（解耦和），可以做到线程对资源的共享。
实现Runnable接口的优势：
1.避免了单继承的局限性，还可以共性抽取，继承其他类和实现其他接口；
2.增强了程序的扩展性,降低了程序的耦合性(解耦)
3.使用实现的方式，可以实现资源共享，而继承Thread类的方式不能实现资源共享的方式。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题的产生是因为：当两个以上的线程同时访问一个共享数据，并对其进行写操作的时候，就会出现数据的异常，这就是线程安全问题。
对于可能出现线程安全问题的代码,因为在Java程序中运行是单线程，所以只需要规定当一个线程抢到CPU的执行权对一个共享数据进行访问时，无论是否失去CPU的执行权，都要让线程完成对共享数据的修改。
解决线程安全问题一共有3种方式。
第一种是：同步代码块，把可能出现线程安全问题的代码放入同步代码块中执行，线程执行代码需要通过同一个而且唯一一个锁对象，因此就保证了多线程执行过程中不会有线程安全问题。
第二种是：同步方法。把可能出现线程安全问题的代码放入一个由synchronized的方法中，一次只能有一个线程执行该方法。
第三种是：锁机制。对于可能出现线程安全问题的代码前调用lock()方法，然后再调用完成后使用unlock()方法，即可做到一次只能有一个线程执行代码。

4.sleep()方法和wait()方法的区别？
答：
1.sleep()方法是通过Thread类直接调用使用的，而wait()方法是通过锁对象调用的
2.线程使用sleep方式进入休眠，在经过设定的毫秒值之后休眠结束，会和其他线程去抢CPU的执行权，而线程使用wait（）方式进入休眠，会无限等待，需要其他拥有相同锁对象的线程调用notify()方法才能唤醒。
3.线程通过sleep()方法进入休眠后不会释放锁对象，线程调用wait方法进入无限等待后会释放锁对象。

1.多线程的实现有几种方式？实现步骤分别是怎样的？有两种方式,一种是通过创建Thread类的子类重写Thread类中的run方法写好需要线程执行的功能,然后通过子类对象调用Thread类中的start方法启动一个新线程；另外一种是通过接口Runnable为非Thread子类的类提供一种激活方式，通过实现Runnable的类创建对象并将这个实现类的对象作为创建Thread类对象的参数，然后用Thread类的对象调用start方法去启动新线程。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类是将线程任务和线程对象都放到一个子类，实现Runnable接口的话只作为线程任务。优势有1、不占用继承位，只是占用一个接口位置。2、接口实现的方式将两个功能拆开，使用更灵活，解耦合。3、可以实现资源共享。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程共享同一个资源并对这个资源的数据进行写操作的话就会产生线程安全问题。有3中方式解决线程安全问题：1、同步代码块 2、使用同步方法，同步方法又分为普通同步方法和静态同步方法。3、使用lock锁。
4.sleep()方法和wait()方法的区别？

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程有两种实现方式
1.继承Thread类。步骤：1.创建自定义类，继承Thread类 2.重写run方法 3.在测试类中new新建的类，创建Thread子类对象。4.用子类对象调用start（）方法，开启线程。
2.实现Runnable接口。步骤：1.创建Runnable接口的实现类。2.在实现类中重写run方法。3.在测试类中，创建Runnable实现类对象。4.file:///C:\Users\Thinkpad\AppData\Local\Temp\SGPicFaceTpBq\27768\0588E73B.png由于Runnable接口没有开启线程的方法，创建Thread类的对象，并且把Runnable实现类对象作为参数传入Thread类中。5.通过Runnable的方法start（）方法开启线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：区别是实现Runnable接口没有start（）方法，而继承Thread类有开启线程的start（）方法。
继承Runnable接口的优势是：1.run方法的设置线程任务和start方法开启线程进行分离（解耦合）。2.避免了Thread的单继承的尴尬，因为java只能是单继承，这个类继承了Thread就不能进行共性抽取了。而Runnable接口实现可以多实现，可以自由进行功能的拓展。


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题产生的原因是多个线程访问了共享数据，并且进行了写操作。线程安全都是由全局变量和静态变量引起的。
解决线程安全问题可以通过：1.同步代码块 2.同步方法（同步静态方法）3.lock锁机制


4.sleep()方法和wait()方法的区别？
答：sieep（）方法是线程休眠，休眠结束后，会和其他线程抢夺CPU的执行权。进入休眠不会释放锁对象。
wait（）方法是线程等待，调用该方法时，线程进入无限期的休眠状态，直到另一个线程调用notify（）方法对他唤醒。
调用wait()方法时，会释放锁对象。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
继承Thread类：创建Thead的子类，重写run()方法，在测试类中创建子类对象调用start()方法；
实现Runnable类：创建Runnable的实现类；重写run方法，在测试类中创建实现类的对象，在Thread中传入对象参数，创建Thread的对象，再调用start方法；
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Runnable 实现类解决了继承的弊端，保留了继承的位置，还实现了多个接口，并且提高了程序的扩展性，降低了耦合度，同时把任务代码分享给多个线程共享。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程的安全问题是多个线程抢占同一组数据时候产生的，解决方案：
   1，同步代码块方法：synchorinized（同步锁可以是任意的对象）
   2，同步方法（:使用synchronized修饰的方法）
   3，静态同步方法(对于静态同步方法的同步锁用this)
   4，锁紧机制（lock（），unlock（））
4.sleep()方法和wait()方法的区别？
1，sleep()是静态的方法可以直接用Thread来调用；wait()是动态的方法，需要创建对象来调用；
2，sleep()是休眠状态  休眠期过去就自动加入程序的运行；wait()的空参方法需要系调用notify()方法来唤醒；
3，有参数的wait()方法需要等到参数时间到达继续执行程序；