第二篇 并发，多线程

1、并发编程的三个必要因素：

  • 原子性：原子，即一个不可再被分割的颗粒。原子性指的是一个或多个操作要么全部执行成功要么全部执行失败。
  • 可见性：一个线程对共享变量的修改,另一个线程能够立刻看到。（synchronized,volatile）
  • 有序性：程序执行的顺序按照代码的先后顺序执行。（处理器可能会对指令进行重排序）

2、在 Java 程序中怎么保证多线程的运行安全？

  • 出现线程安全问题的原因一般都是三个原因：
    1. 线程切换带来的原子性问题 解决办法：使用多线程之间同步synchronized或使用锁(lock)
    2. 缓存导致的可见性问题 解决办法：synchronized、volatile、LOCK，可以解决可见性问题
    3. 编译优化带来的有序性问题 解决办法：Happens-Before 规则可以解决有序性问题

3、并行和并发有什么区别？

  • 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行
  • 并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。
  • 串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

4、如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？

  • windows上面用任务管理器看，linux下可以用 top 这个工具看。
    1. 找出cpu耗用厉害的进程pid， 终端执行top命令，然后按下shift+p (shift+m是找出消耗内存最高)查找出cpu利用最厉害的pid号
    2. 根据上面第一步拿到的pid号，top -H -p pid 。然后按下shift+p，查找出cpu利用率最厉害的线程号，比如top -H -p 1328
    3. 将获取到的线程号转换成16进制，去百度转换一下就行
    4. 使用jstack工具将进程信息打印输出，jstack pid号 > /tmp/t.dat，比如jstack 31365 > /tmp/t.dat
    5. 编辑/tmp/t.dat文件，查找线程号对应的信息

5、什么是线程死锁？

  • 死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。
  • 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

6、形成死锁的四个必要条件是什么？

  1. 互斥条件：在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，就只能等待，直至占有资源的进程用毕释放。
  2. 占有且等待条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
  3. 不可抢占条件：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。（比如一个进程集合，A在等B，B在等C，C在等A）

7、如何避免线程死锁？

  1. 避免一个线程同时获得多个锁
  2. 避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源
  3. 尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制

8、创建线程的四种方式

  • 继承 Thread 类；

    public class MyThread extends Thread {
@Override
public void run() {
    System.out.println(Thread.currentThread().getName() + " run()方法正在执行...");
}

  • 实现 Runnable 接口；

    public class MyRunnable implements Runnable {
@Override
public void run() {
    System.out.println(Thread.currentThread().getName() + " run()方法执行中...");
}

  • 实现 Callable 接口；

    public class MyCallable implements Callable<Integer> {
@Override
public Integer call() {
    System.out.println(Thread.currentThread().getName() + " call()方法执行中...");
    return 1;
}

  • 使用匿名内部类方式

    public class CreateRunnable {
    public static void main(String[] args) {
        //创建多线程创建开始
        Thread thread = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("i:" + i);
                }
            }
        });
        thread.start();
    }
}

9、说一下 runnable 和 callable 有什么区别？

相同点：

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start()启动线程

主要区别：

  • Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果

  • Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息 注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

10、什么是 Callable 和 Future?

  • Callable 接口类似于 Runnable，从名字就可以看出来了，但是 Runnable 不会返回结果，并且无法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以返回值，这个返回值可以被 Future 拿到，也就是说，Future 可以拿到异步执行任务的返回值。
  • Future 接口表示异步任务，是一个可能还没有完成的异步任务的结果。所以说 Callable用于产生结果，Future 用于获取结果。

11、什么是 FutureTask？

  • FutureTask 表示一个异步运算的任务。FutureTask 里面可以传入一个 Callable 的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。只有当运算完成的时候结果才能取回，如果运算尚未完成 get 方法将会阻塞。一个 FutureTask 对象可以对调用了 Callable 和 Runnable 的对象进行包装，由于 FutureTask 也是Runnable 接口的实现类，所以 FutureTask 也可以放入线程池中。

12、线程的状态

  • 新建(new)：新创建了一个线程对象。

  • 就绪（可运行状态）(runnable)：线程对象创建后，当调用线程对象的 start()方法，该线程处于就绪状态，等待被线程调度选中，获取cpu的使用权。

  • 运行(running)：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

  • 阻塞(block)：处于运行状态中的线程由于某种原因，暂时放弃对 CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被 CPU 调用以进入到运行状态。

      • (一). 等待阻塞：运行状态中的线程执行 wait()方法，JVM会把该线程放入等待队列(waitting queue)中，使本线程进入到等待阻塞状态；
      • (二). 同步阻塞：线程在获取 synchronized 同步锁失败(因为锁被其它线程所占用)，，则JVM会把该线程放入锁池(lock pool)中，线程会进入同步阻塞状态；
      • (三). 其他阻塞: 通过调用线程的 sleep()或 join()或发出了 I/O 请求时，线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O 处理完毕时，线程重新转入就绪状态。

  • 死亡(dead)(结束)：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

13、线程调度器选择优先级最高的线程运行，但是，如果发生以下情况，就会终止线程的运行：

  1. 线程体中调用了 yield 方法让出了对 cpu 的占用权利
  2. 线程体中调用了 sleep 方法使线程进入睡眠状态
  3. 线程由于 IO 操作受到阻塞
  4. 另外一个更高优先级线程出现
  5. 在支持时间片的系统中，该线程的时间片用完

14、线程同步以及线程调度相关的方法

  • wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；
  • sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理 InterruptedException 异常；
  • notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 确定唤醒哪个线程，而且与优先级无关；
  • notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

15、sleep() 和 wait() 有什么区别

  • 相同：两者都可以暂停线程的执行
  • 不同：
    1. 类的不同：sleep() 是 Thread线程类的静态方法，wait() 是 Object类的方法。
    2. 是否释放锁：sleep() 不释放锁；wait() 释放锁。
    3. 用途不同：Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。
    4. 用法不同：wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒。或者可以使用wait(long timeout)超时后线程会自动苏醒。

16、Thread 类中的 yield 方法有什么作用？

  • 使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。
  • 当前线程到了就绪状态，那么接下来哪个线程会从就绪状态变成执行状态呢？可能是当前线程，也可能是其他线程，看系统的分配了。

17、线程的 sleep()方法和 yield()方法有什么区别？

  1. sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
  2. 线程执行 sleep()方法后转入阻塞（blocked）状态，而执行 yield()方法后转入就绪（ready）状态；
  3. sleep()方法声明抛出 InterruptedException，而 yield()方法没有声明任何异常；
  4. sleep()方法比 yield()方法（跟操作系统 CPU 调度相关）具有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。

18、如何停止一个正在运行的线程？

  • 在java中有以下3种方法可以终止正在运行的线程：
  1. 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
  2. 使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。
  3. 使用interrupt方法中断线程。

19、notify() 和 notifyAll() 有什么区别？

  • 如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
  • notifyAll() 会唤醒所有的线程，notify() 只会唤醒一个线程。
  • notifyAll() 调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而 notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制

20、当一个线程进入一个对象的 synchronized 方法 A 之后，其它线程是否可进入此对象的 synchronized 方法 B？

不能。其它线程只能访问该对象的非同步方法，同步方法则不能进入。因为非静态方法上的 synchronized 修饰符要求执行方法时要获得对象的锁，如果已经进入A 方法说明对象锁已经被取走，那么试图进入 B 方法的线程就只能在等锁池（注意不是等待池哦）中等待对象的锁。

21、synchronized、volatile、CAS 比较

  1. synchronized 是悲观锁，属于抢占式，会引起其他线程阻塞。
  2. volatile 提供多线程共享变量可见性和禁止指令重排序优化。
  3. CAS 是基于冲突检测的乐观锁（非阻塞）

22、synchronized 和 Lock 有什么区别？

  • 首先synchronized是Java内置关键字，在JVM层面，Lock是个Java类；
  • synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。
  • synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。
  • 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

23、synchronized 和 ReentrantLock 区别是什么？

  • synchronized 是和 if、else、for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别。既然 ReentrantLock 是类，那么它就提供了比synchronized 更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量

  • 相同点：两者都是可重入锁

  • 主要区别如下：

    1. ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；
    2. ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；
    3. ReentrantLock 只适用于代码块锁，而 synchronized 可以修饰类、方法、变量等。
    4. 二者的锁机制其实也是不一样的。ReentrantLock 底层调用的是 Unsafe 的park 方法加锁，synchronized 操作的应该是对象头中 mark word

    Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

    • 普通同步方法，锁是当前实例对象
    • 静态同步方法，锁是当前类的class对象
    • 同步方法块，锁是括号里面的对象

24、volatile 关键字的作用

  • 对于可见性，Java 提供了 volatile 关键字来保证可见性和禁止指令重排。 volatile 提供 happens-before 的保证，确保一个线程的修改能对其他线程是可见的。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主内存中，当有其他线程需要读取时，它会去内存中读取新值。
  • 从实践角度而言，volatile 的一个重要作用就是和 CAS 结合，保证了原子性，详细的可以参见 java.util.concurrent.atomic 包下的类，比如 AtomicInteger。
  • volatile 常用于多线程环境下的单次操作(单次读或者单次写)。

25、volatile 变量和 atomic 变量有什么不同？

  • volatile 变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用 volatile 修饰 count 变量，那么 count++ 操作就不是原子性的。
  • 而 AtomicInteger 类提供的 atomic 方法可以让这种操作具有原子性如getAndIncrement()方法会原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。

26、synchronized 和 volatile 的区别是什么？

  • synchronized 表示只有一个线程可以获取作用对象的锁，执行代码，阻塞其他线程。
  • volatile 表示变量在 CPU 的寄存器中是不确定的，必须从主存中读取。保证多线程环境下变量的可见性；禁止指令重排序。
  • 区别：
    1. volatile 是变量修饰符；synchronized 可以修饰类、方法、变量。
    2. volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性和原子性。
    3. volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。
    4. volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。
    5. volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。

27、Lock 接口和synchronized 对比同步它有什么优势？

  • synchronized和lock 都有可重入性.

  • synchronized在进入锁池后,会不停得等待直到获取锁对象,无法中断,是真爱.而lock可以设置等待时间停止锁竞争

    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

  • synchronized是内置的,而lock是一个接口.

  • synchronized在运行结束后或者异常后会自动释放锁,而lock需要自己手动释放锁

  • synchronized是非公平锁,而lock可以是非公平锁也可以是公平锁.用布尔值来选择类型.

    public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

  • lock还有读写锁

28、乐观锁和悲观锁的理解及如何实现，有哪些实现方式？

  • 悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。再比如 Java 里面的同步原语 synchronized 关键字的实现也是悲观锁。
  • 乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于 write_condition 机制，其实都是提供的乐观锁。在 Java中 java.util.concurrent.atomic 包下面的原子变量类就是使用了乐观锁的一种实现方式 CAS 实现的。

29、什么是 CAS

  • CAS 是 compare and swap 的缩写，即我们所说的比较交换。
  • cas 是一种基于锁的操作，而且是乐观锁。在 java 中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加 version 来获取数据，性能较悲观锁有很大的提高。
  • CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和 A 的值是一样的，那么就将内存里面的值更新成 B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a 线程获取地址里面的值被b 线程修改了，那么 a 线程需要自旋，到下次循环才有可能机会执行。

30、CAS 的会产生什么问题？

  1. ABA 问题

  2. 循环时间长开销大：

    对于资源竞争严重（线程冲突严重）的情况，CAS 自旋的概率会比较大，从而浪费更多的 CPU 资源，效率低于 synchronized。

  3. 只能保证一个共享变量的原子操作：

    当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。

posted @   Posion゜  阅读(28)  评论(0)  编辑  收藏  举报
相关博文：
· 第三偏 线程池
· 第一篇-数据库相关
· Java 并发多线程面试题及答案
· CAS+Synchronized
· Java并发整理
阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· Manus爆火，是硬核还是营销？
· 一文读懂知识蒸馏
· 终于写完轮子一部分：tcp代理 了，记录一下
点击右上角即可分享
微信分享提示