黑马程序员技术交流社区

标题: 【厦门JavaEE就业5期-每日总结】线程、同步 [打印本页]
作者: 厦门校区    时间: 2018-12-26 18:21
标题: 【厦门JavaEE就业5期-每日总结】线程、同步
1.多线程的实现有几种方式？实现步骤分别是怎样的？
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
作者: Wujainwei    时间: 2018-12-26 19:39
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种。（1）创建一个子类继承Thread，重写run()方法即可。创建对象后使用start()调用
          （2）创建一个Runnable接口的实现类，重写run方法。创建Runnable接口的实现类对象，再创建Thread对象使用其有参构造Thread（Runnable实现类），再使用start()调用。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别在实现Runnable接口拥有继承Thread方法不具备的优势
Runnable接口的优势体现在1、避免了单继承的局限性
                                          2、增强了程序拓展性，降低耦合性（解耦）
                                          3、实现资源共享

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
当多线程访问共享数据并执行写操作时，就会发生线程安全问题；
解决线程问题有三种方式：
方案一：同步代码块（锁对象为任意对象   obj）
方案二：同步方法（锁对象是实现类本身，也就是this）
方案三：静态方法（锁对象是本类的class对象--RunnableImpl.class）

4.sleep()方法和wait()方法的区别？
sleep()参数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。
而wait（）无参方法将进入无限睡眠，如果没有notify方法唤醒就不会恢复运行
wait()数列表输入long值 ，代表毫秒值，在休眠指定毫秒后将自动恢复运行。不过可以提前被notify 唤醒
作者: 陈佳鹏    时间: 2018-12-26 19:51
一.两种；
通过创建Thread的子类来实现多线程：
1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程
通过创建Thread的有参构造传入Runnable实现类的对象来实现多线程：
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。
3. 调用线程对象的start()方法来启动线程。
二.如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。总结：实现Runnable接口比继承Thread类所具有的优势：1. 适合多个相同的程序代码的线程去共享同一个资源。2. 可以避免java中的单继承的局限性。3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
三.多个线程对同一组资源进行写操作会产生线程安全问题；当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。有三种方式完成同步操作：
1. 同步代码块。
2. 同步方法（包括静态同步方法）。
3. 锁机制。
四.sleep()方法是计时等待，wait()是无限等待。sleep()方法是Thread类下的方法，wait()是Object类下的方法。
作者: 赵烈刚    时间: 2018-12-26 19:59
1.多线程的实现有几种方式？实现步骤分别是怎样的？
3种,一丶Thread     二丶Runnable     三丶匿名内部类
Thread:创建一个子类继承Thread,重写run()方法,在run()方法内设置线程任务,在主(main)方法内创建子类对象,子类对象调用start()方法开启子线程。
Runnable:创建一个实现类实现Runnable接口,重写run()方法,在run()方法内设置线程任务,在主(main)方法内创建实现类对象,再创建一个Thread对象,将实现类对象传入Thread内如:(Thread rd = new Thread(实现类对象);),通过Thread方法间接得到Start()方法开启线程。
匿名内部类:这个是通过前两种方法而得到的一个迷你版,直接在主(main)方法内new Thread或者Runnable格式如下:
new Thread(){
//重写run方法
//run方法内设置线程任务
}.start;

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread的话不适合资源共享,实现Runnable的话可以实现资源共享,正所谓单继承多实现;
实现Runnable接口优势在于避免了单继承的局限性,降低程序的耦合度,可以达到资源共享的效果。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
在多个线程执行同一组数据的时候会产生线程安全问题;解决线程安全问题的方式有:
1).同步方法 同步代码块(对象锁是  this)
2).静态同步方法(锁是类的字节码文件对象)
3).锁机制获取(加)锁(lock()和释放锁(unlock()）
4.sleep()方法和wait()方法的区别？
sleep()方法就像是我们人睡觉,睡到一定时候自然醒过来继续干活;
wait()方法就像是植物人,除非有外界因素(notify()方法)将它唤醒,否则一直沉睡不醒;
作者: 吴少华    时间: 2018-12-26 20:03
1.多线程的实现有几种方式？实现步骤分别是怎样的？

答：继承thread类和实现Runnable接口俩种

继承thread方法:
1.先继承thread方法
2.重写run方法，
3.在测试类中创建自定义类的类对象
4.对象.start开启线程

实现Runnable接口方法：
1.先实现Runnable接口
2.重写run方法。
3.在测试类中创建自定义类的类对象
4.创建thread对象把自定义类的类对象放进thread对象中
5.thread对象.start方法开启线程

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

1.继承Thread类是继承thread类，实现Runnable类是实现Runnable接口，开启线程相比比较繁琐

2.继承Thread类线程代码块存放在Thread子类的run方法中
   实现Runnable，线程代码存放在接口的子类的run方法中，可以被多实现。

实现Runnable接口的优势：

1.继承的位置只有一个，接口可以实现多个接口。
2.可以多个程序的线程共享同一个资源
3.thread耦合性比较高，Runnable接口解耦效果好，灵活性好

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
原因：由于多个程序在同步运行的过程中，限制条件只会对其中的一条产生限制，使其停止，但是其他线程没有收到限制停止的指令，就会可能同时运行同一·段代码，出现值相同的问题，这就是线程安全问题

一共有3种方法
1.同步代码块：创建 object 的同步锁对象
                      synchorinized（相同同步锁){共同执行的方法体}

2.静态方法： synchorinized（类名.class控制）{共同执行的方法体}

3.lock方法： 创建 lock对象
                    lock.lock方法开启同步锁
                   {共同执行的方法体}
                    lock.unlick方法释放同步锁
4.sleep()方法和wait()方法的区别？
区别：
1.sleep在使用时需要设定时间，自己醒来
  wait可以自己设定时间自己醒来，也可以通过别人的nitify方法来唤醒他

2.sleep方法是通过thread的类来调用
   wait方法要通过本类的唯一锁对象来调用。

3.sleep在同步过程中睡眠同步锁并不会归还。
  wait方法在同步过程中冻结，同步锁归还
作者: 吴洪标    时间: 2018-12-26 20:22
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唤醒。

作者: 陈彬    时间: 2018-12-26 21:00
1.多线程的实现有几种方式？实现步骤分别是怎样的？
        继承Thread类: 继承Thread类,并重写Run()方法,在Run()方法中写出线程要操作的功能,然后使用子类对象名.start()来启用线程,不能使用对象名.Run()方法来调用,使用对象名.Run()方法并不是启用线程!只是普通的对象调用方法而已.
        实现Runnable接口:创建Runnable接口的实现类,并且重写Run()方法，然后创建实现类对象,因为Runnable接口中并没有Start()方法,所以要创建Thread对象,把Runnable的实现类对象传入,然后通过.Start()方法来调用.
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
         如果是继承Thread类不适合资源共享,实现Runnable接口容易实现资源共享
         实现Runnable接口的优势
         在JAVA中,只支持单继承,如果我们继承了Thread类,那么我们就不能再继承其的类.这样是有局限性的.
         可以解除程序的耦合性,如果使用继承,那么每次创建对象时,都会使用到该对象的资源,这样就使得程序的耦合性过高,如果是使用实现接口的方法来创建线程,那么可以大大降低程序的耦合性.
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
          当多个线程访问同一个数据时,并且有进行修改数据等操作时,会出现线程安全问题.比如售票,多个窗口同时售票,如果不同步的话,会出现重复的票或者是不存在的票.
1.同步代码块
          synchronized(对象锁){
                把需要同步的代码.
           }
       当多个线程访问时,只有第一个线程能拿到对象锁,并且带走对象锁,直到该块代码执行完成,才会吧锁归还,其他线程在执行到此代码时,如果没有对象锁,则会进入阻塞状态,直到拿到对象锁的线程执行完代码并且释放对象锁时,才能拿到对象锁并且进入代码中执行代码.使用同步代码块的前提是多个线程必须使用同一把锁.
2.同步方法 同步方法分为静态方法,和非静态方法.
非静态同步方法的创建格式为,
修饰符   synchronized 返回值类型 方法名称(参数列表){
           这里面放需要同步的代码
}
静态同步方法的创建格式为,
修饰符  static synchronized 返回值类型 方法名称(参数列表){
           这里面放需要同步的代码
}
关于对象锁,非静态方法的对象锁是Thsi,而静态方法的对象锁为(类名.class)     
3.Lock锁
    Lock锁是从JAVA1.5开始引入的,他可以自己设置加锁的位置,和释放锁的位置. 通过对象.lock()方法可以实现加锁操作,还可以通过对象.unlock()方法实现解锁操作.
4.sleep()方法和wait()方法的区别？
       sleep()方法是休眠指定的时间,不需要其他线程唤醒的,只要指定的时间一到,那么会自动醒来,重新加入抢夺CPU执行权的大军中
       而wait()方法如果不带参数的话,那么需要其他线程通过调用notify()方法或者notifyAll()方法来唤醒他.
如果wait()方法中带了参数,如果其他线程没有唤醒他,那么他到指定的时间以后也能自己醒来.



作者: Chidori    时间: 2018-12-26 21:07
1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种方式
第一种方式：
  • 创建一个thread子类
  • 在thread类的子类中重写thread类中的run方法，设置线程任务（开启线程要做什么）
  • 创建thread类的子类对象
  • 调用thread类中的start方法，开启新线程，执行run方法

第二种方式
1、创建一个Runnable接口实现类
2、在实现类中重写Runnable接口中的run（）方法
3、创建实现类的对象
4、创建thread类的对象，使用有参构造（实现类的对象）
5、启用thread类的对象调用start方法，启动run方法
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
实现Runnable接口接口不能直接调用start（）方法，必须使用thread的有参构造，来调用Runnable接口中的run（）方法
实现Runnable接口的优势在于，不用占用实现类的继承位，一个类只能有一个父类，但是可以有多个实现类，所以，使用Runnable接口降低了程序的耦合性，增强了程序的扩展性
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多个线程在执行同一个进程时，有可能会产生相同的结果，这就是线程的安全问题
解决安全问题的方式有：同步代码块、同步方法、静态同步方法、lock锁
4.sleep()方法和wait()方法的区别？
sleep（）方法是线程休眠，休眠结束会和其他线程抢占CPU，进入休眠不是释放锁对象
wait（）方法是线程进入无线等待阶段，直到另一个线程调用notify（）方法，才会解除等待和其他对象抢占CPU。使用wait（）方法，程序会释放锁对象




作者: 林文悦    时间: 2018-12-26 21:08
1.多线程的实现有几种方式？实现步骤分别是怎样的？

有两种方式。

Thread：     首先定义一个子线程类继承Thread，并在子线程中重写Thread 的run方法。

                     定义一个测试类，在测试类中new一个子线程对象。调用子线程对象的 start 方法，开启子线程    。

Runnable：定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

                    创建Runnable实现类的实例，并以此实例作为Thread的参数来创建Thread对象，该Thread对象才是真正的线程对象。

                     调用线程对象的start()方法来启动线程。   

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

区别：    java只能单继承，因此如果是采用继承Thread的方法，那么在以后进行代码重构的时候可能会遇到问题，因为你无法继承别的类了 ；

               如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

Runnable接口优势：

    ① 适合多个相同的程序代码的线程去处理统一资源的情况

    ②可以避免由于java单继承特征带来的局限性  

    ③增强开发程序的健壮性，代码可以多个线程共享，代码和数据是独立的 ，解耦合。



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

原因：

1. 存在着两个或者两个以上的线程。 2. 多个线程共享了一个资源， 并且对这个资源进行操作。
2. 方式：      同步代码块 (隐式锁)：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。   
                     同步方法(隐式锁)  ：使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,                        其他线程只能在方法外 等着。
                      同步锁 Lock：比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。   

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

区别：

sleep()方法正在执行的线程主动让出CPU（然后CPU就可以去执行其他任务），在sleep指定时间后CPU再回到该线程继续往下执行(注意：sleep方法只让出了CPU，而并不会释放同步资源锁 )；

wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行。（注意：notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度）；

sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用；
作者: 续扬    时间: 2018-12-26 21:09
1.多线程的实现有几种方式？实现步骤分别是怎样的？

Thread：在子线程重写run方法，在主线程中调用start方法执行run方法

Ruannable：创建Ruannable接口，接口重写run方法，在主线程中创建接口实现类对象，创建Thread类传递实现类对象，调用Thread类start方法执行run方法

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
Thread占用了继承导致无法抽取其他共性。
一个类又是线程对象又执行任务，耦合度太高。
不适合资源共享
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
多线程同时读写一个数据会发生安全问题。
ssynchronized同步代码块；同步方法，同步静态方法；lock锁。
4.sleep()方法和wait()方法的区别？
sleep设置时间到点自己醒。锁还在自己手里
wait没有Noitify调用醒不了。锁还回去了。
作者: 杨鑫棋    时间: 2018-12-26 21:09
1.多线程的实现有几种方式？实现步骤分别是怎样的？

多线程的实现方式有两种，分别是：继承Thread类和实现Runnable接口。

继承Thread类，实现步骤：

1.定义一个类，继承Thread类

2.重写run()方法



3.在测试类中创建子类对象，调用start()方法


实现Runnable接口，实现步骤：

1.创建Runnable接口的实现类



2.实现类中重写接口Runnable的方法，设置线程任务



3.创建Runnable接口的实现类对象



4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象



5.调用Thread类中的start方法 ，开启新的线程执行run方法。


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

实现Runnable接口需要创建Thread类对象，在构造方法中传递Runnable接口的实现类对象，然后再调用Thread类中的start方法 ，开启新的线程执行run方法。

实现Runnable接口的优势：

1.避免单继承的局限性



2.增强了程序的扩展性，降低了程序的耦合性（解耦）

把设置线程和开启新线程进行了分离


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

多个线程同时访问同一资源，可能会出现同时使用资源的情况，就会产生线程安全问题。
可以通过4种方式解决问题：

1.同步代码块：
用synchronized(锁对象){

       
        可能会出现线程安全问题的代码块（访问了共享数据的代码）


}


2.同步方法：
把访问了共享数据的代码抽取出来，放到一个方法中。在方法上添加synchronized修饰符。

3.静态同步方法：

就是在同部分方法的基础上，加上static修饰符。

4.使用Lock锁：

1.在成员位置创建一个ReentrantLock对象



2.在可能出现安全问题的代码前调用Lock接口中的方法void lock()获取锁



3.在可能出现安全问题的代码前调用Lock接口中的方法void unlock()释放锁


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

slee方法：

sleep方法是让线程睡眠，线程进入睡眠状态，会放弃CPU的执行权，那么线程睡醒后，会和其他线程一起去抢夺CPU的执行权。

wait方法：

wait方法会让线程无限等待，直到超时满期或者接受到唤醒通知的方法notify方法。
作者: 骆颖权    时间: 2018-12-26 21:11
1.多线程的实现有几种方式？实现步骤分别是怎样的？（1）方式一 继承Thread类        步骤：1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
                  2. 创建Thread子类的实例，即创建了线程对象
                  3. 调用线程对象的start()方法来启动该线程
（2）方式二  实现Runnable接口
        步骤 ：1.. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
                   2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
                   3. 调用线程对象的start()方法来启动线程。


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
继承Thread类就无法继续继承其他类，无法做到资源共享。而实现Runnable接口可以继续继承其他类。
实现Runnable接口的优势： 1.避免了单继承的局限性
                                           2.增强了程序的扩展性，降低了程序的耦合性（解耦）。
                                           3. 适合多个相同的程序代码的线程去共享同一个资源。


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
在多个线程同时读写同一组数据的时候会产生线程安全问题
解决的方式有三种：（1）同步代码块
                               （2）同步方法
                               （3）lock锁

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

sleep（）方法没有释放锁，而wait（）方法释放了锁。
调用sleep()方法导致了程序暂停执行指定的时间，让出cpu执行权给其他线程，当指定的时间到了又会自动恢复运行状态。
而当调用wait()方法的时候，线程会放弃对象锁，只有针对此对象调用notify()方法后本线程才会恢复运行状态。

作者: 苏志祥    时间: 2018-12-26 21:16

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()方法需要等到参数时间到达继续执行程序；
作者: 董志超Eric    时间: 2018-12-26 21:18
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()方法时，会释放锁对象。


作者: 陈基林    时间: 2018-12-26 21:35
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()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

作者: 许晓明    时间: 2018-12-26 21:36
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方法进入无限等待后会释放锁对象。
作者: zhuyiming    时间: 2018-12-26 21:37
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会释放锁对象

作者: 周章强    时间: 2018-12-26 21:46

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()方法才能解冻，冻结期间同步锁会放给其他线程。
作者: 刘荣城    时间: 2018-12-26 21:48
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方法解冻。
作者: lj478360767    时间: 2018-12-26 21:50

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()方法后本线程才进入对象锁定池准备
获取对象锁进入运行状态。
作者: 李灵杰    时间: 2018-12-26 21:52
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 唤

作者: 陈辉阳    时间: 2018-12-26 21:56
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外 等着

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

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。 Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。 public void unlock() :释放同步锁。
作者: 洪烁铭    时间: 2018-12-26 21:57
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方法来唤醒，否则就一直无限等待。




作者: 陈益源    时间: 2018-12-26 21:58
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方法会释放锁对象
作者: 赖熙蒙    时间: 2018-12-26 22:00
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方法唤醒就不会恢复运行。





作者: 苏阿合    时间: 2018-12-26 23:15
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方法会释放锁对象
作者: 杨馥榕    时间: 2018-12-27 00:53
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是永久性睡眠，需要有人来叫醒，不然不会醒
作者: ab8846254    时间: 2018-12-27 18:16
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中 必须由锁对象调用



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

作者: 李柏刚    时间: 2018-12-28 01:15
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后边的代码。并且可以达到循环呼应的效果。
作者: 王宇鹏    时间: 2018-12-28 15:07
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式。继承以及实现接口
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
使用继承的方式，占用继承位；使用实现的方式，不占用继承位，而是占用的一个接口位置


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


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

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2