多线程（三）

35. 并行和并发有什么区别？

  • 并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

  • 并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。

  • 在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群。

并发，指的是多个事情，在同一时间段内同时发生了。 
并行，指的是多个事情，在同一时间点上同时发生了。

并发的多个任务之间是互相抢占资源的。 
并行的多个任务之间是不互相抢占资源的、

只有在多CPU的情况中，才会发生并行。否则，看似同时发生的事情，其实都是并发执行的。

https://cloud.tencent.com/developer/article/1424249

 

36. 线程和进程的区别？

定义：

  • 进程：是执行中的一段程序，即程序被载入到内存中并被执行，它就是一个进程。进程是表示资源分配的基本概念，又是调度运行的基本单位，是系统并发执行的基本单位。
  • 线程：单个进程中执行的每个任务就是一个线程。线程是进程中执行运算的最小单位。

https://www.cnblogs.com/qq1069284034/p/10530178.html

 

37. 守护线程是什么？

守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程，这是它的作用——而其他的线程只有一种，那就是用户线程。所以java里线程分2种，

  • 守护线程：比如垃圾回收线程，就是最典型的守护线程。
  • 用户线程：就是应用程序里的自定义线程。
 
https://blog.csdn.net/qq_36838191/article/details/80274722
 
38. 创建线程有哪几种方式？

①. 继承Thread类创建线程类

  • 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

  • 创建Thread子类的实例，即创建了线程对象。

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

②. 通过Runnable接口创建线程类

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

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

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

③. 通过Callable和Future创建线程

  • 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

  • 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

  • 使用FutureTask对象作为Thread对象的target创建并启动新线程。

  • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

https://www.cnblogs.com/tanyang/p/11176103.html
 
39. 说一下 runnable 和 callable 有什么区别？

  • Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；

  • Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。（方法为futureTask.get()，会阻塞主线程的运行）

https://www.cnblogs.com/ConstXiong/p/12009131.html
 
40. 线程有哪些状态？

线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

  • 创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

  • 就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。

  • 运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

  • 阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。

  • 死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪 

https://blog.csdn.net/xingjing1226/article/details/81977129

 

41. sleep() 和 wait() 有什么区别？

  • sleep()：方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。
  • wait()：wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

https://blog.csdn.net/xyh269/article/details/52613507

 

42. notify()和 notifyAll()有什么区别？

  • 如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。

  • 当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。

  • 优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

https://blog.csdn.net/djzhao/article/details/79410229

 

43. 线程的 run()和 start()有什么区别？

  • 调用 start() 方法是用来启动线程的，轮到该线程执行时，会自动调用 run()；直接调用 run() 方法，无法达到启动多线程的目的，相当于主线程线性执行 Thread 对象的 run() 方法。
  •  一个线程对线的 start() 方法只能调用一次，多次调用会抛出 java.lang.IllegalThreadStateException 异常；run() 方法没有限制。

每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
————————————————
版权声明：本文为CSDN博主「ConstXiong」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/meism5/article/details/90240272

 

44. 创建线程池有哪几种方式？

  • newFixedThreadPool(int nThreads)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程。

  • newCachedThreadPool()

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。

  • newSingleThreadExecutor()

这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行。

  • newScheduledThreadPool(int corePoolSize)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

 

https://blog.csdn.net/meism5/article/details/90261021

 

45. 线程池都有哪些状态？

  • 线程池有5种状态：Running、ShutDown、Stop、Tidying、Terminated。

https://blog.csdn.net/l_kanglin/article/details/57411851

 

46. 线程池中 submit()和 execute()方法有什么区别？

  • execute()：只能执行 Runnable 类型的任务。
  • submit()：可以执行 Runnable 和 Callable 类型的任务。
  • submit有返回值，而execute没有
  • submit方便Exception处理

47. 在 java 程序中怎么保证多线程的运行安全？

线程安全在三个方面体现：

  • 原子性：一个或者多个操作在 CPU 执行的过程中不被中断的特性
  • 可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到
  • 有序性：程序执行的顺序按照代码的先后顺序执行

https://blog.csdn.net/meism5/article/details/90266334

 

48. 多线程锁的升级原理是什么？

  • 在Java中，锁共有4种状态，级别从低到高依次为：无状态锁，偏向锁，轻量级锁和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级。

http://ifeve.com/java-synchronized/

 

49. 什么是死锁？

  • 所谓死锁是指多个进程因竞争资源而相互等待，若无外力作用，这些进程都无法向前推进。

https://blog.csdn.net/TuxedoLinux/article/details/86555026

 

50. 怎么防止死锁？

产生死锁必须满足以下四个条件，缺一不可：

  • 互斥条件   一个资源只能被一个进程所占用，此时若其它进程请求该资源，则请求进程必须等待
  • 不剥得条件   进程使用的资源在未完成使用之前，不能被其它进程强行得走。
  • 请求和保持条件   一个进程因为请求资源而阻塞时，对已获资源保持不放
  • 循环等待条件   若干进程形成了一种头尾相接环状等待资源的关系

处理策略

  • 预防死锁   破坏死锁产生的四个必要条件之一
  • 避免死锁   在资源的动态分配过程中，用某种方法防止系统进入不安全状态，从而避免死锁
  • 死锁检测及解除   通过系统检测机构及时的检测出死锁的发生，然后采取某种策略解除死锁

https://blog.csdn.net/TuxedoLinux/article/details/86555026

 

51. ThreadLocal 是什么？有哪些使用场景？

  • ThreadLocal 是线程本地存储，在每个线程中都创建了一个 ThreadLocalMap 对象，每个线程可以访问自己内部 ThreadLocalMap 对象内的 value。
但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心，在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。
 
  • 经典的使用场景是为每个线程分配一个 JDBC 连接 Connection。这样就可以保证每个线程的都在各自的 Connection 上进行数据库的操作，不会出现 A 线程关了 B线程正在使用的 Connection； 还有 Session 管理 等场景。
————————————————
版权声明：本文为CSDN博主「ConstXiong」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/meism5/article/details/90413860
 
52.说一下 synchronized 底层实现原理？
  • Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。
（每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权）
 
https://www.cnblogs.com/paddix/p/5367116.html
 
53. synchronized 和 volatile 的区别是什么？
  • volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
  • volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
  • volatile仅能实现变量的可见性，不能保证原子性；而synchronized则可以保证变量的可见性和原子性
  • volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
  • volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化
https://www.cnblogs.com/kaleidoscope/p/9506018.html
 
54. synchronized 和 Lock 有什么区别？
  • 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
  • synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
  • synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
  • 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
  • synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
  • Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

 

https://www.cnblogs.com/iyyy/p/7993788.html
 
55. synchronized 和 ReentrantLock 区别是什么？
  • synchronized 竞争锁时会一直等待；ReentrantLock 可以尝试获取锁，并得到获取结果
  • synchronized 获取锁无法设置超时；ReentrantLock 可以设置获取锁的超时时间
  • synchronized 无法实现公平锁；ReentrantLock 可以满足公平锁，即先等待先获取到锁
  • synchronized 控制等待和唤醒需要结合加锁对象的 wait() 和 notify()、notifyAll()；ReentrantLock 控制等待和唤醒需要结合 Condition 的 await() 和 signal()、signalAll() 方法
  • synchronized 是 JVM 层面实现的；ReentrantLock 是 JDK 代码层面实现
  • synchronized 在加锁代码块执行完或者出现异常，自动释放锁；ReentrantLock 不会自动释放锁，需要在 finally{} 代码块显示释放
     

补充一个相同点：都可以做到同一线程，同一把锁，可重入代码块。

 

56. 说一下 atomic 的原理？

  • Atomic包中的类基本的特性就是在多线程环境下，当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以向自旋锁一样，继续尝试，一直等到执行成功。
  • Atomic系列的类中的核心方法都会调用unsafe类中的几个本地方法。我们需要先知道一个东西就是Unsafe类，全名为：sun.misc.Unsafe，这个类包含了大量的对C代码的操作，包括很多直接内存分配以及原子操作的调用，而它之所以标记为非安全的，是告诉你这个里面大量的方法调用都会存在安全隐患，需要小心使用，否则会导致严重的后果，例如在通过unsafe分配内存的时候，如果自己指定某些区域可能会导致一些类似C++一样的指针越界到其他进程的问题。

 

https://blog.csdn.net/wuzhiwei549/article/details/82621947

posted @ 2020-02-05 21:08  圣痕道心  阅读(90)  评论(0)    收藏  举报