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 唤

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

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

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

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.多线程的实现有几种方式？实现步骤分别是怎样的？ 答：多线程有两种实现方式，继承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方法唤醒就不会恢复运行。

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.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种
一种：创建一个子类继承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.多线程的实现有几种方式？实现步骤分别是怎样的？ 答：多线程实现总共有两种方式，   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()方法。
使用实现类的方式实现，定义一个类，实现runnable接口 ，重写run（）方法，在测试类中创建实现类对象，创建线程对象Thread。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类占用继承位，耦合度高，不能实现资源共享
实现Runnable接口不占用继承位，只占用一个接口位置，功能拆开解耦合，可以实现资源共享。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程共享一个资源时，并对这个资源的数据进行写入操作时，会产生线程安全问题。
解决线程安全问题的方式有：同步代码块，同步方法和同步锁。
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.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式。继承以及实现接口
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
使用继承的方式，占用继承位；使用实现的方式，不占用继承位，而是占用的一个接口位置


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


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

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