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

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种分别是继承Thread类来创建和定义Runnable接口的实现类；
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接口的优势体现在哪里？
答：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
三种方式解决：同步代码块，synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问；同步方法，使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着；Lock锁,lock()加同步锁unlock() :释放同步锁

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

陈志铖 发表于 2019-3-26 21:39
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式 创建继承Thread的子类      new Thread(借口R ...

同步代码块,同步方法,lock锁

叶凌青
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.多线程的实现有几种方式？实现步骤分别是怎样的？
答:继承Thread和实现Runnable接口两种。
   Thread的实现步骤：a.继承Thread类  b.重写run方法  c.创建子类对象  d.子类对象.start方法
   Runnable接口的实现步骤：a.实现Runnable接口  b.重写run方法  c.创建子类对象 d.创建Thread对象，new Thread（子类对象）  e.使用start方法开启线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：实现Runnable接口比继承Thread类所具有的优势：
    a.适合多个相同的程序代码的线程去共享同一个资源。
    b.可以避免java中的单继承的局限性。
    c.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
    d.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：多个线程在抢CPU时，抢到CPU的线程代码还没执行完，CPU又跑去执行另外一条线程，造成数据重复以及不存在的数据产生。
    当线程抢到资源要执行时，需要用锁锁住，让线程执行完再释放锁。
    有同步代码块，同步方法，和lock锁三种方式解决。
4.sleep()方法和wait()方法的区别？
答：sleep（）方法属于Thread类，会自动唤醒自己，代码执行完时不释放锁。
    wait（）方法属于Object类，需要notify方法进行唤醒，代码执行完后会释放锁。

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

第一种:继承Thread类实现

步骤:

1.创建Thread类的子类,继承Thread类.

2.重写Thread类的run方法

3.创建子类对象

4.调用Thread类的Start方法,开启多线程任务,执行run方法.

第二种:实现Runnable接口

步骤:

1.创建Runnable接口的实现类,并重写run方法

2.创建一个实现类对象

3.创建一个Thread类对象,并将实现类对象作为参数传入

4.调用Thread类对象的Start方法,开启多线程任务,执行run方法.



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

如果一个类继承Thread类,则不适合资源共享,而实现Runnable接口的话,则比较容易进行资源共享.

优势好处体现在:

1.避免了单继承的局限性

2.增加了程序的拓展性,耦合度更低,实现解耦操作.

3.适合多个相同代码的线程共享同一个资源



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

线程安全问题产生的原理:多个线程共享同一个资源,同时执行同一个资源的数据,就会出现线程安全问题

三种:

1.同步代码块方式(重点)

2.同步方法(包含静态方法)

3.Lock锁



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

区别:

1.wait来源于Object类中的方法,sleep来源于Thread类中的方法

2.wait方法被调用时,会归还锁对象和释放CPU执行权.而sleep方法被调用时,只会释放CPU执行权

陈开明：
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种实现方式。
一种通过继承Thread实现。首先先定义一个继承Thread类的子类，然后重写run()方法，最后在主线程测试类中创建具体的Thread对象，调用start(）方法开启线程。
一种是通过创建Runnable接口的实现类来创建线程。首先先创建一个实现Runnable的实现类，然后在主线程测试类中创建Runnable实现类的具体对象，最后将这个对象作为参数，传递给Thread类，创建具体线程对象。
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
1、避免了单继承的局限性。2、增强了程序扩展性，降低了程序的耦合性。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程访问同一资源，且多个线程对资源有写的操作时候，就可能出现线程安全问题。
使用同步机制解决，有3种方法解决线程安全问题。
1、同步代码块。2、同步方法。3、锁方法。
4.sleep()方法和wait()方法的区别？
sleep()是线程暂停一段时间，其中没有释放对象锁。
wait()是线程暂停一段时间，其中释放了对象锁。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式 创建继承Thread的子类      new Thread(借口Runnable的实现类)
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
避免了单继承的局限性
增强了程序的扩展性,降低了程序的耦合性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
sleep并没有释放锁对象

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种，一种是继承Thread类方式，一种是实现Runnable接口方式。
（1）继承Thread类方式：创建一个子类继承Thread类，重写里面的run（）方法，
创建该子类对象，调用start（）方法。
（2）实现Runnable接口方式：创建一个Runnable实现类，重写run（）方法，
通过Thread的有参构造方法将Runnable实现类作为参数，创建一个Thread对象调用start（）方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）继承的特点是单继承，而实现的特点是多实现。因此，继承Thread就无法继承其他类，
而实现runable接口还能去实现其他接口，去继承类；
（2）继承Thread类，创建子类对象后，开启线程和运行线程任务是绑定在一起的，耦合度太高，
不利于后期修改，以及线程任务的共享；而实现runable接口则接口的实现类中设置线程任务，
开启线程通过创建Thread对象，则两者是分开的，降低耦合度，增强了程序的拓展性。
优势：耦合性低，线程任务和线程对象分开；可以反复使用线程任务，实现资源共享。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
（1）因为当有多个线程调用方法当中的变量，如果同步进行则线程安全，如果有sleep();或者wait(long timeout)等
其他让线程停顿的方法时线程进行不同步则会让变量输出变得混乱从而影响线程安全。
（2）有3种方法
1. 同步代码块：运用synchronized(同步锁){需要同步操作的代码}  把大括号里的内容锁住让线程把大括号里程序走完。
2. 同步方法：即为synchronized修饰的方法，则是保证线程在执行该方法时其他线程在外面等待。
3. 锁机制：新建一个ReentrantLock()对象，调用lock和unlock方法加同步锁和释放同步锁使用格式执行同步
操作代码前加同步锁方法，结束后执行释放同步锁方法

4.sleep()方法和wait()方法的区别？
sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动苏醒。sleep方法进入到睡眠不会释放锁对象

wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤醒。wait方法会释放锁对象，
wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现有两种方式,一种是通过继承,另一种是通过接口实现
继承:创建一个子类,继承Thread,重写父类中的run()方法,创建对象,开启线程
接口:创建一个接口实现类,实现Runnable接口,重写run()方法,创建对象,
再创建Thread将创建的对象传入Thread中,开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承:创建的每一个线程都是一个崭新的线程
实现:一个线程对象可以多次被开启
实现的优势:同一个线程可以多次被开启,一个子类只能继承一个父类,继承Thread会占用继承父类

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
线程安全问题时怎么产生的:同一块代码区域被多条线程进行改写造成的线程安全问题;
如何解决线程安全问题:通过加synchronized来解决线程安全问题;有三种方式解决;
1)同步代码块
2)同步方法
3)锁机制

4.sleep()方法和wait()方法的区别？
sleep()属于Thread,wait()属于Object,sleep()休眠期间不会归还锁,wait()休眠期间会归还锁

1.多线程的实现有几种方式？实现步骤分别是怎样的？
        第一种：
        1.子类继承Thread类
        2.重写Thread类的run方法(执行的任务)
          3.在测试类中创建子类对象
        4.调用start方法开启线程
        第二种：
        1.实现类实现Runnable接口
        2.重写接口中的run方法（线程任务）
        3.在测试类中创建线程对象Thread，将实现类作为参数传递进去
        4.调用start方法开启线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        1.继承Thread类占用了继承位，无法实现其他继承关系；而Runnable接口是实现类，不影响继承。
        2.继承Thread类子类既需要穿件对象，又有线程任务，耦合度太高；而Runnable接口只是实现线程的任务功能，
        3.继承Thread类多个对象无法共享资源；而Runnable接口可以创建多个对象是，实现资源共享。所以，Runnable接口避免了单继承性的局限性，又降低了耦合度
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        线程安全问题：当多个线程操作同一个资源，并对这个资源的数据进行修改操作的时候，就会出现线程安全问题
        1.同步代码块  synchronized(同步锁){
需要同步操作的代码
}   
2.同步方法
普通的同步方法
public synchronized void method(){
可能会产生线程安全问题的代码
}   
静态的同步方法
public staticsynchronized void method(){
可能会产生线程安全问题的代码
}   
对于普通的同步方法，锁对象是this
对应静态的同步方法，锁对象是类名.class字节码对象
        3.Lock锁
Lock lock = new ReentrantLock();    创建锁对象
lock.lock();开启锁
包裹的代码——需要同步的代码
lock.unlock();释放锁
4.sleep()方法和wait()方法的区别？
        sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动苏醒。sleep方法进入到睡眠不会释放锁对象
wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执行权

1.多线程的实现有几种方式？实现步骤分别是怎样的？
（1）自定义线程类子类对象：
        1.创建一个Thread类的子类；
        2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）；
        3.创建Thread类的子类对象；   
        4.调用Thread类中的start方法，开启新的线程，执行run方法。

（2）实现Runnable接口，重写run方法。
        1.创建一个Runnable接口的实现类；
        2.在实现类中重写Runnable接口的run方法，设置任务；
        3.创建Runnable接口的实现类对象；
        4.直接创建Thread类对象，构造方法中传递Runnalbe接口的实现类对象（不需要自定义线程类了）；
        5.调用Thread类中的start方法，开启新的线程执行run方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
（1）继承Thread类：相对耦合度高。
（2）实现Runaable接口：相对耦合度低。
（3）优势：
        1.可以实现多接口，避免继承Thread类的单继承的局限性。
        2.适合多个线程的资源共享，提高了代码的复用性。
        3.使线程的创建和运行分离，实现解耦的目的。
3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
（1）产生的原因：如果多个线程在同时运行同一段代码，并且对同一份数据同时进行了读写的操作，那么就容易引起数据的错误，即为线程不安全。
（2）解决的方式：
        1.同步代码块：
        synchronized(Object 同步锁){
                可能导致线程安全问题的代码；
        }
        2.同步方法：
        修饰符 synchronized 返回值 方法名（参数列表）{
                可能导致线程安全问题的代码；
        }
        3.Lock锁：
                Lock lock = new ReentrantLock();
                lock.lock();
                可能导致线程安全问题的代码；
                lock.unlock();
4.sleep()方法和wait()方法的区别？
（1）sleep方法不会释放同步锁，而wait方法将释放同步锁；
（2）sleep方法属于Thread类，wait方法属于Object类。

1.多线程的实现有几种方式？实现步骤分别是怎样的？
Thread类：
1.子类继承Thread类
2.重写run方法
3.创建Thead对象
4.调用start方法

Runnable接口：
1.子类实现Runnable接口
2.重写run方法
3.创建Runnable对象
4.创建Thread对象
5.调用start方法       
               
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类，不能资源共享，实现Runnable接口，能资源共享
a. 适合多个相同的程序代码的线程去共享同一个资源。
b. 可以避免java中的单继承的局限性。
c. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
d. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多个线程对同一个资源进行操作时，就会出现线程安全问题

同步代码块
同步方法
Lock锁

4.sleep()方法和wait()方法的区别？
sleep()方法是Thread类中方法，不需要锁对象，只释放CPU执行权
wait()方法是Object类中方法，需要锁对象，释放CUP执行权和锁对象

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接口更符合“专人专事”的思想。
实现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.多线程的实现有几种方式？
    答：有两种
  实现步骤分别是怎样的？
    答：（1）继承Thread类
        1.子类继承Thread类
        2.重写Thread类的run方法
        3.在测试类中创建子类对象
        4.调用start方法开启线程
        （2）实现Rannable接口
        1.实现类实现Runnable接口
        2.重写接口中的run方法
        3.在测试类中创建线程对象Thread，将实现类作为参数传递进去
        4.调用start方法开启线程   
2.继承Thread类和实现Runnable接口有啥区别？
    答：继承Thread类：占用了继承位；在Thread之类中重写run（）方法，不能够实现多个线程执行同一段代码。耦合度太高。
           实现Runnable接口：实现了Runnable接口还能继承其它类，在Runnable实现类重写run（）方法，通过构造方法传入Runnable实现类对象作为参数创建Thread类     象调用start（）方法开启新线程，可以实现多个线程执行同一段代码，降低了耦合度。
实现Runnable接口的优势体现在哪里？
  答：优势：
（1）        避免了单继承的局限性
（2）        增强了程序的扩展性，降低了程序的耦合性
（3）        实现了Runnable接口的方式，将线程任务和开启新线程进行了分离。
3.线程安全问题时怎么产生的？
    答：[多个线程]在执行[同一资源]并对这个资源进行[数据的修改]
    如何解决线程安全问题，有哪几种方式？
    答：有三种方法，分别是：1.同步代码块 2.同步方法 3.Lock锁
4.sleep()方法和wait()方法的区别？
    答：sleep方法来源于Thread类，让线程进入睡眠，指定睡眠时间，时间到了以后，自动
苏醒。sleep方法进入到睡眠不会释放锁对象
          wait方法来源于Object类，让线程进入等待，指定等待时间，或者不指定知道其他线程唤
醒。wait方法会释放锁对象，wait方法想要继续执行，必须获得到其他线程的锁对象并抢到CPU执
行权

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，实现runtime接口，但实际上都是实现了runtime接口，而继承Thread类还有单继承局限
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口的优势： 1. 适合多个相同的程序代码的线程去共享同一个资源。 2. 可以避免java中的单继承的局限性。 3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。 4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样 的，而且其他的变量的值也和预期的是一样的，就是线程安全的。线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全
4.sleep()方法和wait()方法的区别？
Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。
5.线程有几种状态？他们之间是如何转化的？
NEW(新建) 线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行) 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。
Blocked(锁阻 塞) 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限 等待) 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时 等待) 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated(被 终止) 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

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.多线程的实现有几种方式？实现步骤分别是怎样的？
答：（1）继承Thread类 ：首先新建一个类来继承Thread类；在继承类中重写Thread类中的run方法，在run写任务代码；
；创建继承类对象；调用start方法来开启线程
      （2）实现Runnable接口：首先新建一个接口实现类，重写run方法，在run方法中写任务代码；创建接口实现类对象；
创建Thread对象，传入接口实现类对象作为参数；调用start方法开启线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类单继承；而Runnable接口是实现类，可以实现多个接口；继承Thread类子类耦合度太高；而Runnable接口只是实现线程的任务功能，Runnable接口可以创建多个对象来共享资源；

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：同一块代码区域被多条线程进行改写造成的线程安全问题；有三种形式：同步代码块；同步方法；锁机制；

4.sleep()方法和wait()方法的区别？
答：sleep()方法是Thread,wait()方法是Object,sleep()进入睡眠是不会还锁的,而wait()休眠期间会释放锁的

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：
    有两种方式，一种是通过继承Thread类和实现Runnable接口：
    继承Thread类的步骤：1.定义一个Therad子类2.重写run方法，方法内写入需要执行的方法体3.创建Therad子类对象4.调用Therad中的starrt方法来开启子线程和执行run方法

     实现Runnable接口步骤：1.创建实现类2，重写run方法，方法中写入需要执行的方法体3.创建实现类对象4.创建Therad对象，调用构造方法传入实现类5.调用线程对象的start方法创建新的线程，并执行rum方法   
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答;
     1.使用继承的方式，占用继承位，使用实现类的方式，不占继承位
     2.如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很           容易的实现资源共享。
     3..使用继承的方式,耦合度太高,两个功能写在一起;使用实现的方式,两个功能拆开,解耦合;
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：
      当多线程访问共享数据并执行写操作时，就会发生线程安全问题；
      解决线程问题有三种方式：
      方案一：同步代码块（锁对象为任意对象   obj）
      方案二：同步方法（锁对象是实现类本身，也就是this）
      方案三：静态方法（锁对象是本类的class对象--RunnableImpl.class）

4.sleep()方法和wait()方法的区别？
    sleep()参数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。
     而wait（）无参方法将进入无限睡眠，如果没有notify方法唤醒就不会恢复运行
     wait()数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。不过可以提     前被notify 唤醒

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种：(1)创建Thread的子类，重写run()方法，在测试类中创建子类对象，通过子类对象调用Start方法执行run方法内容
(2)创建Runable接口的实现类，重写run方法，在测试类中创建实现类对象，创建以接口实现类为参数的Thread对象，通多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()方法的区别？
sleep()方法执行时会放弃CPU，但不会放弃锁对象。
wait()方法执行时，都放弃了对CPU和锁对象的竞争。