黑马程序员技术交流社区

标题: 【厦门JavaEE就业8期-每日总结】多线程 [打印本页]
作者: 厦门校区    时间: 2019-6-28 17:02
标题: 【厦门JavaEE就业8期-每日总结】多线程
1.多线程的实现有几种方式？实现步骤分别是怎样的？
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
4.sleep()方法和wait()方法的区别？
作者: 王猛虎    时间: 2019-6-28 21:07
1.实现多线程的方法有两种
a.类继承Thread类，重写run()方法，测试类中创建该子类对象并调用start()方法。
b.类实现Runnable接口，重写run()方法，测试类中创建该实现类对象，创建一个Thread线程对象调用带参构造，并以该实现类对象为参数，调用Thread类对象的start方法。

2.继承Thread类实现的多线程，各个线程执行的内容互不相干，实现Runnable接口的多线程，各个线程执行内容是同一代码块。
继承Thread类的类，可以直接调用start方法开启线程，实现Runnable接口的类需要再创建一个Thread以该实现类对象为参数的线程类，然后调用Thread类对象的start方法开启线程。
Runnable接口的优势在于不占用继承位置，实现类与类之间的解耦合。

3.多个线程同时访问共享资源，并对共享资源进行修改。
解决：将修改操作封装成一个原子操作
a.使用Synchronized代码块包裹代码
b.使用Synchronized修饰方法
c.使用加锁lock和释放锁unlock

4.sleep(long n)方法是Thread类的一个静态方法，表示休眠多少毫秒，休眠时间一到自动苏醒
wait()方法是Object类的方法，表示等待，再没有唤醒的情况下不会自动苏醒。
作者: 郑梅月    时间: 2019-6-28 21:16

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种方式，分别是通过继承Thread类、实现Runnable接口。
继承Thread类实现步骤：
（1）一个类名为MyThread继承Thread类
（2）重写run方法
（3）在测试类创建线程MyThread对象
（4）MyThread对象调用start()方法启动线程
实现Runnable接口步骤：
（1）一个类实现Runnable接口
（2）重写run方法
（3）在测试类中创建线程任务对象
（4）创建线程对象，传递线程任务和线程名称
（5）调用start()方法启动线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类和实现Runnable接口都能够实现多线程，但由于继承的单一性，若使用了继承Thread类的方法后续便不能在继承其他类了，而以实现Runnable接口的方法可以继承其他类。
实现Runnable接口的好处：
（1）避免了Java单继承的局限性
（2）适合多个相同的程序代码去处理同一个任务资源的情况，把线程和程序的代码、数据有效的分离，较好的体现了面向对象的设计思想。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题的产生原因：多线程操作同一个资源，并对其执行操作的时候。
解决方式有三种：
（1）同步代码块
（2）同步方法
（3）lock锁
4.sleep()方法和wait()方法的区别？
答：sleep和wait都是线程的阻塞方法，但sleep是Thread类的方法，wait是Object类的方法。
   调用sleep()方法对象会暂时失去CPU的执行权，锁对象不会被放弃，当休眠时间到会自动获得CPU的执行权
   使用wait()方法对象的会失去CPU的执行权，锁对象被放弃，需要调用notify()方法才会唤醒对象。
作者: 郑梅月    时间: 2019-6-28 21:17

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种方式，分别是通过继承Thread类、实现Runnable接口。
继承Thread类实现步骤：
（1）一个类名为MyThread继承Thread类
（2）重写run方法
（3）在测试类创建线程MyThread对象
（4）MyThread对象调用start()方法启动线程
实现Runnable接口步骤：
（1）一个类实现Runnable接口
（2）重写run方法
（3）在测试类中创建线程任务对象
（4）创建线程对象，传递线程任务和线程名称
（5）调用start()方法启动线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类和实现Runnable接口都能够实现多线程，但由于继承的单一性，若使用了继承Thread类的方法后续便不能在继承其他类了，而以实现Runnable接口的方法可以继承其他类。
实现Runnable接口的好处：
（1）避免了Java单继承的局限性
（2）适合多个相同的程序代码去处理同一个任务资源的情况，把线程和程序的代码、数据有效的分离，较好的体现了面向对象的设计思想。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题的产生原因：多线程操作同一个资源，并对其执行操作的时候。
解决方式有三种：
（1）同步代码块
（2）同步方法
（3）lock锁
4.sleep()方法和wait()方法的区别？
答：sleep和wait都是线程的阻塞方法，但sleep是Thread类的方法，wait是Object类的方法。
   调用sleep()方法对象会暂时失去CPU的执行权，锁对象不会被放弃，当休眠时间到会自动获得CPU的执行权
   使用wait()方法对象的会失去CPU的执行权，锁对象被放弃，需要调用notify()方法才会唤醒对象。
作者: 许雅丽    时间: 2019-6-28 21:19
1.多线程的实现有几种方式？实现步骤分别是怎样的？

两种：

        1.用继承的方法，让子类继承Thread父类，重写run方法，在测试类调用子类方法并执行

        2.用实现接口类，在Runnable的实现类里重写run方法，在测试类里通过创建实现类对象再创建Thread对象，并执行

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

用实现Runnable接口的方法比较好

- 避免了Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

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

是因为线程执行的随机性产生的

可以用Synchronized方法，或者lock/unlock方法



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

sleep是暂停执行，等暂停时间过去了之后就可以再次执行

wait是永远暂停，知道notify唤醒它
作者: 郑梅月    时间: 2019-6-28 21:19

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种方式，分别是通过继承Thread类、实现Runnable接口。
继承Thread类实现步骤：
（1）一个类名为MyThread继承Thread类
（2）重写run方法
（3）在测试类创建线程MyThread对象
（4）MyThread对象调用start()方法启动线程
实现Runnable接口步骤：
（1）一个类实现Runnable接口
（2）重写run方法
（3）在测试类中创建线程任务对象
（4）创建线程对象，传递线程任务和线程名称
（5）调用start()方法启动线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类和实现Runnable接口都能够实现多线程，但由于继承的单一性，若使用了继承Thread类的方法后续便不能在继承其他类了，而以实现Runnable接口的方法可以继承其他类。
实现Runnable接口的好处：
（1）避免了Java单继承的局限性
（2）适合多个相同的程序代码去处理同一个任务资源的情况，把线程和程序的代码、数据有效的分离，较好的体现了面向对象的设计思想。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题的产生原因：多线程操作同一个资源，并对其执行操作的时候。
解决方式有三种：
（1）同步代码块
（2）同步方法
（3）lock锁
4.sleep()方法和wait()方法的区别？
答：sleep和wait都是线程的阻塞方法，但sleep是Thread类的方法，wait是Object类的方法。
   调用sleep()方法对象会暂时失去CPU的执行权，锁对象不会被放弃，当休眠时间到会自动获得CPU的执行权
   使用wait()方法对象的会失去CPU的执行权，锁对象被放弃，需要调用notify()方法才会唤醒对象。


作者: 孙健健    时间: 2019-6-28 21:30

1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现方式有俩种，分别是继续Thread类实现Runnable接口
都重写run方法


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

因为在java中，是单继承多实现，我们只是为了重写run方法，所以我们用实现，
实现的优势体现在避免了java单继承的局限性

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

4.sleep()方法和wait()方法的区别？
sleep（）是时间到了自动结束
wait方法，需要等待唤醒
作者: 许俊杰    时间: 2019-6-28 21:32

1.多线程的实现有几种方式？实现步骤分别是怎样的？
        实现多线程有两种方式。
        第一种方式：继承Thread类
                1:定义一个类MyThread继承Thread类
                2:在MyThread类中重写run()方法
                3:创建MyThread类的对象
                4:启动线程

        第二种方式：实现Runnable接口
                1:定义一个类MyRunnable实现Runnable接口
                2:在MyRunnable类中重写run()方法
                3:创建MyRunnable类的对象
                4:创建Thread类的对象，把MyRunnable对象作为构造方法的参数
                5:启动线程


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        区别：继承Thread类不一定要重写run()方法，实现Runnable接口必须要重写run()方法
        优势：
                1.避免了java单继承的局限性
                2.适合多个相同程序的代码去处理同一个资源的情况，把侠女恒和程序的代码、数据有效的分离较好的体现了面向对象的思想

3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
        线程安全问题的产生
        （1）多线程环境
        （2）数据共享
        （3）多条语句操作共享数据

        解决方法有三种：
        （1）1.        同步代码块，给多条操作语句上锁，只能有一个线程能执行synchronized(任意对象){代码块}
        （2）同步方法使用synchronized修饰方法，锁对象是this
        （3）静态同步方法使用static synchronized修饰方法，锁对象是 类型.class


4.sleep()方法和wait()方法的区别？
        sleep（）方法需要给定指定的时间，时间一到就会继续进行抢夺
        wait（）方法是使线程等待，需要唤醒才能继续进行抢夺
作者: 李保佳    时间: 2019-6-28 21:39

1.多线程的实现有几种方式？实现步骤分别是怎样的？
1.定义一个类MyThread继承Thread类 在MyThread类中重写run()方法 创建MyThread类的对象 启动线程
2.定义一个类MyRunnable实现Runnable接口 在MyRunnable类中重写run()方法 创建MyRunnable类的对象 创建Thread类的对象，把MyRunnable对象作为构造方法的参数 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现
Runnable接口的优势体现在哪里？
避免了Java单继承的局限性 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现 了面向对象的设计思

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
1.安全问题出现的条件
是多线程环境 有共享数据 有多条语句操作共享数据
2.如何解决多线程安全问题呢?
基本思想：让程序没有安全问题的环境

解决方法 ：同步代码块，同步方法  ，lock锁

4.sleep()方法和wait()方法的区别？
sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。

sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃

sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒
作者: 张遵荣    时间: 2019-6-28 21:42

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现有两种方式。
第一：new一个Thread的实现子类，在测试类中new 该子类，启动线程
第二：new一个接口Runnable的实现类，重写run，在测试类中new该实现类，将此实现类作为Thread对象的参数，启动线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread的方案，和实现Runnable接口的方案，在测试类中创建线程对象，前者的方案，每个对象都进行了同样的代码操作
，耦合性更高，后者的方案则可以将需要都执行的操作抽取出来。
实现Runnable接口，比继承的方案，在解耦合上更优越，且java是单继承机制，继承位珍贵，可以使用接口，尽量不使用继承

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题的产生有三个必要的条件，一，该进程有多个线程。二，此多个线程都可以访问同一数据。三，多个线程可以
对该共享数据进行修改操作。满足这三者就有线程安全问题的存在
解决线程安全问题，有三种方案，第一，使用被SynchronousQueue修饰包裹的代码块。二，使用同步方法，三，使用lock锁

4.sleep()方法和wait()方法的区别？
答：前者是静态方法，前者是暂时失去执行权，有时段参数，而后者如果没有唤醒操作的话，是无限时地失去执行权的
作者: 辛全旺    时间: 2019-6-28 21:43

1.多线程的实现有几种方式？实现步骤分别是怎样的？
        答：两种方式。       
        第一种：1、创建任务类继承Thread，重写run方法。2、测试类创建任务类对象。3、任务类对象用strat()方法开启线程。
        第二种：1、创建任务类实现Runnable接口，重写run方法。2、测试类创建任务类对象。3、使用任务类对象创建Thread对象。4、Thread对象用strat()方法开启线程。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        答：继承Thread类开启线程，多个线程资源不共享。实现Runnable开启线程多个线程可以共享资源。Runnable接口的优势在与节省了任务类继承位，可以使多线程共用资源。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
        答：在多线程环境下，有代码对共享资源进行写操作就是产生线程安全问题。通过把操控共享资源的代码锁起来，一次只让一个线程去运行就可以解决线程安全问题，有三种方式：同步代码块、同步方法、lock锁

4.sleep()方法和wait()方法的区别？
        答：sleep()方法只是使线程暂时失去CPU执行权和强抢夺权，定时时间结束又可以抢夺CPU执行权来运行代码。wait()方法线程失去CPU执行权和强抢夺权，不能自动再获取，只能由其他线程调用notify()方法来唤醒，才能抢夺CPU执行权来运行代码。
作者: 邹楷能    时间: 2019-6-28 21:44
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种方式。一种是继承Thread类，定义一个类让其继承Thread，重写run()方法，创建对象，调用start()方法。第二种是实现Runnable接口，定义一个类让其实现该接口，重写run()方法，创建Thread对象，传入实现类对象参数，调用start()方法。

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：区别是一个继承，一个实现，实现接口的优势是能够避免java单继承的局限性，同时适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想。

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：在多线程环境下，有代码对共享数据进行操作的时候就会发生线程安全问题。
解决方式有三种：1.同步代码块  2.同步方法 3.lock锁

4.sleep()方法和wait()方法的区别？
答：sleep()方法是让线程能够暂停休眠，时间到了会自动唤醒，继续运行。
而wait()方法是让线程等待，如不唤醒则会一直等待，直到收到唤醒信号notify()或者notifyAll()后才会继续运行。
作者: 陈伟锋    时间: 2019-6-28 21:44

1.多线程的实现有几种方式？实现步骤分别是怎样的？
多线程的实现方法有两种:
第一种是类继承Thread类:定义一个类继承Thread类 -> 在子类重写run 方法 -> 创建子类对象,启动线程
第二种是实现Runnable接口:定义一个类实现Runnable接口 -> 在实现类中重写run方法 -> 创建实现类对象 -> 创建Thread类对象,把实现类对象作为参数传入 -> 启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别:
继承Thread类可以不重写run方法,实现Runnable接口一定要重写run方法
实现Runnable接口的优势:
(1)避免了Java单继承的局限性
(2)适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
产生:当多个线程对同一个资源进行访问,并对这个资源进行写操作时,会出现线程安全问题
解决:
(1)同步代码块
(2)同步方法
(3)Lock锁

4.sleep()方法和wait()方法的区别？
sleep()方法是让一个线程暂停指定毫秒时间,时间到了会继续运行
wait()方法是让一个线程执行等待操作,直到另一个线程调用该对象的 notify()方法或 notifyAll()方法才能继续运行
作者: 林锦长    时间: 2019-6-28 21:45
1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式
方式1：继承Thread类
（1）编写一个类MyThread继承Thread类
（2）重写run()方法，并不是强制重写
（3）在测试类中创建线程MyThread对象
（4）调用start方法开启线程，不是调用run，调用start代表开启线程，JVM会调用run方法

方式2：实现Runnable接口
（1）一个类实现Runnable接口
（2）重写run方法（强制）
（3）在测试类中创建线程任务对象
（4）创建线程对象Thread()，将线程任务传递进去
（5）调用start方法开启线程


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

实现Runnable接口的优势：
（1）避免了Java单继承的局限性，不占用继承位
（2）适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现
了面向对象的设计思想，即将线程任务和线程对象分离，进行解耦。


3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
.线程安全问题出现条件：
（1）是多线程环境
（2）有共享数据
（3）有多条语句操作共享数据
线程安全问题产生原因：当多线程操作同一资源，并执行多条语句操作的时候
解决线程安全问题方式有3种：
（1）同步代码块：锁对象是任意对象，但是必须保证多个线程锁对象是同一个；
                  好处：解决了多线程的数据安全问题；
                  弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的
                            运行效率；
（2）同步方法： 普通同步方法----锁对象是this
                 静态同步方法----类名.class
（3）lock锁：手动的开启锁和释放锁，释放锁需要写在finally代码块中


4.sleep()方法和wait()方法的区别？
区别：
（1）sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。
（2）sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；wait是 CPU执行权和锁对象都放弃
（3）sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒
wait()方法：线程等待---永久等待（直到另一个线程调用该对象的 notify()方法或 notifyAll()方法）
                  
作者: wangdebin    时间: 2019-6-28 21:45

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

第一种 继承Thread类，重写run()方法
第二种 实现Runnable接口，重写run()方法

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

继承Thread类只能单继承，占用了类的继承位  
实现Runnable接口可以多实现，方便类的扩展与复用

实现Runnable接口的优势：将线程任务与线程对象分离，进行解耦，较好的体现了面向对象的封装思想；
                        可以实现多个线程共享同一个资源
                                                不占用继承位


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

当多个线程操作同一段代码，并修改变量时，会出现线程安全问题。
解决方法：
      同步代码块  锁对象是任意对象，但要保证多个线程锁对象是同一个
          同步方法   普通同步方法 锁对象是this
                     静态同步方法 锁对象是类名.class
      lock锁         创建lock的实例ReetranLock() 手动开启锁和释放锁，释放锁需要在finally中                         
         
4.sleep()方法和wait()方法的区别？

sleep()方法 调用之后会放弃CPU执行权，但是不会放弃锁对象，到了时间自动苏醒，去抢夺CPU。
wait()方法 CPU执行权和锁对象都放弃，没有线程唤醒不会自己醒。











作者: 郭伟杰-    时间: 2019-6-28 21:47
1.多线程的实现有几种方式？实现步骤分别是怎样的？

多线程实现方式1：继承Thread类
实现步骤：（1）编写一个类MyThread继承Thread类
          （2）重写run()方法
          （3）在测试类中创建线程MyThread对象
          （4）调用start方法开启线程

多线程实现方式2：实现Runnable接口
实现步骤：（1）一个类实现Runnable接口
          （2）重写run方法（强制）
          （3）在测试类中创建线程任务对象
          （4）创建线程对象Thread(),将线程任务传递进去
          （5）调用start方法开启线程
       

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
一个是继承Thread类，一个是实现Runnable接口
优势:(1)避免了Java单继承的局限性,因为接口时功能的拓展，而继承只有一个继承
     (2)适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好

       的体现了面向对象的设计思想

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

条件：是多线程环境、有共享数据、有多语句操作共享数据，当多个线程对访问同一资源，并且对这个资

     源执行写操作的时候，就会出现线程安全问

如何解决：基本思想：让程序没有安全问题的环境

有哪几种方式：（1）同步代码块解决数据安全的问题
                       （2）同步方法解决数据安全问题
                       （3）lock锁解决数据安全问题

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


答：sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃
    sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒，需要调用notify来唤醒。
作者: 黎先帆    时间: 2019-6-28 21:48

1.多线程的实现有几种方式？实现步骤分别是怎样的？
两种方式：A.继承Thread类；B.实现Runnable接口
继承Thread类
a.编写一个类MyThread继承Thread类
b.重写run()方法（并不是强制重写）
c.在测试类中创建线程MyThread对象
d.调用start方法开启线程（不是调用run，调用start代表开启线程，JVM会调用run方法）
实现Runnable接口
a.一个类实现Runnable接口
b.重写run方法（强制）
c.在测试类中创建线程任务对象
d.创建线程对象Thread(),将线程任务传递进去
e.调用start方法开启线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
区别：
a.继承Thread重写run方法是不强制的，实现Runnable接口重写run方法是强制的
b.继承Thread类的类，可以直接调用start方法开启线程，实现Runnable接口的类需要再创建一个Thread以该实现类对象为参数的线程类，然后调用Thread类对象的start方法开启线程。
c.继承Thread类实现的多线程，各个线程执行的内容互不相干，实现Runnable接口的多线程，各个线程执行内容是同一代码块。
实现Runnable接口的优势：
a.将线程任务和线程对象分离，进行解耦。可以实现多个线程共享同一资源
b.不占用继承位

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
问题产生的原因：当多线程操作同一资源，并执行写操作的时候
有三种方式：
a.同步代码块：锁对象是任意对象，但是必须保证多个线程锁对象是同一个
b.同步方法：
①普通同步方法：锁对象是this
②静态同步方法：锁对象是类名.class
c.lock锁：手动的开启锁和释放锁，释放锁需要写在finally代码块中

4.sleep()方法和wait()方法的区别？
a.sleep和wait都是线程阻塞方法，sleep是Thread类的方法，wait是Object类的方法。
b.sleep调用之后会放弃CPU执行权，但是不会放弃锁对象；Wait  CPU执行权和锁对象都放弃
c.sleep方法到了时间自动苏醒，去抢夺CPU；wait方法没有线程唤醒不会自己醒
作者: 何凯    时间: 2019-6-28 21:55
1.多线程的实现有几种方式？实现步骤分别是怎样的？
有两种
        （1）通过继承Thread类 重写run方法 创建该子类对象，调用start方法，开启多线程 由JVM运行run方法里的代码
        （2）通过实现Runnable接口 重接run方法，创建该实现类，创建Thread类对象实 现类作为线程类的参数，
        ，调用start方法，开启多线程 由JVM运行run方法里的代码


2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
        区别在于继承Thread的线程资源不是共享的 各自执行各自的任务
        实现Runnable的线程是可以共享资源 多线成执行一起执行同一个任务
        实现Runnable的线程类 可以省下一个继承位，可以多线程执行一个任务 共享资源协作

3.线程安全问题是怎么产生的？如何解决线程安全问题，有哪几种方式？
        线程安全问题是多条线程同时对共享的资源进行访问，修改，才会发生线程安全
        解决多线成需要用到同步锁，
有3中方式，一种是用 synchronized把要执行的代码包起来在括号内设置一个其他线程也能访问到的同一，任意对象作为锁
        第二种是在方法返回值前加上synchronized关键字修饰，它的对象锁是this，静态方法的对象锁则是 类名.class
        第三种是Lock锁 创建Lock接口的实现类，调用方法，lock 在代码执行前，代码执行完调用unlock释放锁
       
       


4.sleep()方法和wait()方法的区别？
sleep()是等待设置的时间到了 线程就活了
wait() 等待则是需要其他线程调用notifyAll();方法才会活，如果没有线程调用就一直等待
作者: 林雅彬    时间: 2019-6-28 22:05
1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：多线程的实现有两种方法，继承Thread类和实现Runnable接口
      第一种：编写一个类继承Thread类，重写run()方法，在测试类中创建该类的对象，调用start()方法，启动线程
      第二种：编写一个类实现Runnable接口，重写run()方法，首先在测试类中创建该类的对象，然后创建Tread对象
                   将Runnable实现类的对象作为构造方法的参数传进去，再调用Tread对象的start()方法启动线程

2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：实现Runnable接口避免了Java单继承的局限性
      实现Runnable接口适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，
       较好的体现了面向对象的设计思想

3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：产生线程安全的需要具备3个条件：①是多线程环境 ②有共享数据 ③有多条语句操作共享数据
      解决线程安全问题有3种方式：①用同步代码块synchronized把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
      ② 用同步方法，把synchronized关键字加到方法上③用Lock锁，用它的实现类ReentrantLock，调用lock()加锁方法和unlock()释放锁方法

4.sleep()方法和wait()方法的区别？
答：sleep()方法使当前正在执行的线程停留指定的毫秒数，调用该方法时，当前线程会放弃执行权，等到指定的毫秒数时间到再进去就绪状态，加入抢占CPU队列
wait()方法调用时，当前线程放弃执行权，同时释放锁，直到有其他线程调用notifyAll方法唤醒才能进入就绪状态
  
作者: 郭付民    时间: 2019-6-29 13:20
1.多线程的实现有几种方式？实现步骤分别是怎样的？

（1）继承Thread类
a.定义一个类继承Thread类
b.在类中重写run()方法
c.创建类的对象
d.调用start()方法，启动线程
（2）实现Runnable接口
a.定义一个类实现Runnable接口
b.在实现类中重写run()方法
c.创建实现类的对象
d.创建Thread类的对象,把实现对象作为构造方法的参数
e.调用start()方法，启动线程
JAVA语言是单继承，多实现，单独的一个类没有进行共性的抽取，只是重写方法，又不能做到资源共享，建议用实现。

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

区别;
（1）Runnable是一个是接口，Thread是该接口的一个子类。
（2）Thread不能做到资源共享,线程与线程之间相互独立，也就不会出现安全问题。实现Runnable接口可能会出现安全问题。
（3）继承Thread类可以不重写方法run方法，也可运行（没有意义），实现Runnable接口必须重写run方法。

优势：
（1）避免了Java单继承的局限性。
（2）适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想。
（3）把设置线程任务和开启新线程进行了分离，增加了扩展性，降低了耦合性。

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

线程安全的前提条件是：a.多线程环境 b.有共享数据c.有多条语句操作共享数据。多个线程同时进入到一个代码块，又一同去执行下面的非源子项的代码，造成线程安全问题。
由线程安全的条件，要想解决线程安全，只能对第三条进行操作，解决思路是只能有一个线程进入代码块，直到此线程从代码块出去，其他线程才能进入。
可以得到三种方法：
（1）同步代码块，synchronized(任意对象) { 多条语句操作共享数据的代码 } 就相当于给代码加锁了，任意对象就可以看成是一把锁，但是当线程很多时，效率会低。
（2.1）同步方法，就是把synchronized关键字加到方法上，格式是修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体；}同步方法的锁对象是this。
（2.2）同步静态方法就是把synchronized关键字加到静态方法上，修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体； }同步静态方法的锁对象是什类名.class。
（3）Lock锁,lock()加同步锁，unlock() :释放同步锁。

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

（1）wait()是放弃CPU的执行，无限等待，放弃锁对象，必须调用notify或者notifyAll方法才能唤醒。sleep（）是此线程暂停执行指定时间，给其他线程执行机会，但是依然保持着监控状态，过了指定时间会自动恢复，调用sleep（）方法不会释放锁对象。
（2）sleep()必须要传入参数，wait（）可以不传入参数，也可传入参数。
（3）作用范围，sleep()是一个静态的方法，可以在任何的地方使用，wait（）只能在同步代码块或者同步方法中使用。
作者: 郭付民    时间: 2019-6-29 21:43
1.多线程的实现有几种方式？实现步骤分别是怎样的？

（1）继承Thread类
a.定义一个类继承Thread类
b.在类中重写run()方法
c.创建类的对象
d.调用start()方法，启动线程
（2）实现Runnable接口
a.定义一个类实现Runnable接口
b.在实现类中重写run()方法
c.创建实现类的对象
d.创建Thread类的对象,把实现对象作为构造方法的参数
e.调用start()方法，启动线程
JAVA语言是单继承，多实现，单独的一个类没有进行共性的抽取，只是重写方法，又不能做到资源共享，建议用实现。

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

区别;
（1）Runnable是一个是接口，Thread是该接口的一个子类。
（2）Thread不能做到资源共享,线程与线程之间相互独立，也就不会出现安全问题。实现Runnable接口可能会出现安全问题。
（3）继承Thread类可以不重写方法run方法，也可运行（没有意义），实现Runnable接口必须重写run方法。
优势：
（1）避免了Java单继承的局限性。
（2）适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想。
（3）把设置线程任务和开启新线程进行了分离，增加了扩展性，降低了耦合性。

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

线程安全的前提条件是：a.多线程环境 b.有共享数据c.有多条语句操作共享数据。多个线程同时进入到一个代码块，又一同去执行下面的非源子项的代码，造成线程安全问题。
由线程安全的条件，要想解决线程安全，只能对第三条进行操作，解决思路是只能有一个线程进入代码块，直到此线程从代码块出去，其他线程才能进入。
可以得到三种方法：
（1）同步代码块，synchronized(任意对象) { 多条语句操作共享数据的代码 } 就相当于给代码加锁了，任意对象就可以看成是一把锁，但是当线程很多时，效率会低。
（2.1）同步方法，就是把synchronized关键字加到方法上，格式是修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体；}同步方法的锁对象是this。
（2.2）同步静态方法就是把synchronized关键字加到静态方法上，修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体； }同步静态方法的锁对象是什类名.class。
（3）Lock锁,lock()加同步锁，unlock() :释放同步锁。

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

（1）wait()是放弃CPU的执行，无限等待，放弃锁对象，必须调用notify或者notifyAll方法才能唤醒。sleep（）是此线程暂停执行指定时间，给其他线程执行机会，
但是依然保持着监控状态，过了指定时间会自动恢复，调用sleep（）方法不会释放锁对象。
（2）sleep()必须要传入参数，wait（）可以不传入参数，也可传入参数。
（3）作用范围，sleep()是一个静态的方法，可以在任何的地方使用，wait（）只能在同步代码块或者同步方法中使用。
作者: 郑梅月    时间: 2019-7-2 19:59

1.多线程的实现有几种方式？实现步骤分别是怎样的？
答：两种方式，分别是通过继承Thread类、实现Runnable接口。
继承Thread类实现步骤：
（1）一个类名为MyThread继承Thread类
（2）重写run方法
（3）在测试类创建线程MyThread对象
（4）MyThread对象调用start()方法启动线程
实现Runnable接口步骤：
（1）一个类实现Runnable接口
（2）重写run方法
（3）在测试类中创建线程任务对象
（4）创建线程对象，传递线程任务和线程名称
（5）调用start()方法启动线程
2.继承Thread类和实现Runnable接口有啥区别？实现Runnable接口的优势体现在哪里？
答：继承Thread类和实现Runnable接口都能够实现多线程，但由于继承的单一性，若使用了继承Thread类的方法后续便不能在继承其他类了，而以实现Runnable接口的方法可以继承其他类。
实现Runnable接口的好处：
（1）避免了Java单继承的局限性
（2）适合多个相同的程序代码去处理同一个任务资源的情况，把线程和程序的代码、数据有效的分离，较好的体现了面向对象的设计思想。
3.线程安全问题时怎么产生的？如何解决线程安全问题，有哪几种方式？
答：线程安全问题的产生原因：多线程操作同一个资源，并对其执行操作的时候。
解决方式有三种：
（1）同步代码块
（2）同步方法
（3）lock锁
4.sleep()方法和wait()方法的区别？
答：sleep和wait都是线程的阻塞方法，但sleep是Thread类的方法，wait是Object类的方法。
   调用sleep()方法对象会暂时失去CPU的执行权，锁对象不会被放弃，当休眠时间到会自动获得CPU的执行权
   使用wait()方法对象的会失去CPU的执行权，锁对象被放弃，需要调用notify()方法才会唤醒对象。




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