CS_BLOG
0%

多线程

Posted on In ,
4.7k

java里面的线程和操作系统的线程一样吗？

Java 底层会调用 pthread_create 来创建线程，所以本质上 java 程序创建的线程，就是和操作系统线程是一样的，是 1 对 1 的线程模型。

使用多线程要注意哪些问题？

要保证多线程的程序是安全，不要出现数据竞争造成的数据混乱的问题。
Java的线程安全在三个方面体现：

  • 原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，在Java中使用了atomic包和synchronized关键字来确保原子性；
  • 可见性：一个线程对主内存的修改可以及时地被其他线程看到，在Java中使用了synchronized和volatile这两个关键字确保可见性；
  • 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，在Java中使用了happens-before原则来确保有序性。

保证数据的一致性有哪些方案呢？

  • 事务管理：使用数据库事务来确保一组数据库操作要么全部成功提交，要么全部失败回滚。通过ACID属性，数据库事务可以保证数据的一致性。
  • 锁机制：使用锁来实现对共享资源的互斥访问。在 Java 中，可以使用 synchronized 关键字、ReentrantLock 或其他锁机制来控制并发访问，从而避免并发操作导致数据不一致。
  • 版本控制：通过乐观锁的方式，在更新数据时记录数据的版本信息，从而避免同时对同一数据进行修改，进而保证数据的一致性

线程的创建方式有哪些?

1.继承Thread类

这是最直接的一种方式，用户自定义类继承java.lang.Thread类，重写其run()方法，run()方法中定义了线程执行的具体任务。创建该类的实例后，通过调用start()方法启动线程。

  • 优点: 编写简单，如果需要访问当前线程，无需使用Thread.currentThread ()方法，直接使用this，即可获得当前线程
  • 缺点:因为线程类已经继承了Thread类，所以不能再继承其他的父类

2.实现Runnable接口

如果一个类已经继承了其他类，就不能再继承Thread类，此时可以实现java.lang.Runnable接口。实现Runnable接口需要重写run()方法，然后将此Runnable对象作为参数传递给Thread类的构造器，创建Thread对象后调用其start()方法启动线程。

  • 优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
  • 缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

3.实现Callable接口与FutureTask

java.util.concurrent.Callable接口类似于Runnable，但Callable的call()方法可以有返回值并且可以抛出异常。要执行Callable任务，需将它包装进一个FutureTask，因为Thread类的构造器只接受Runnable参数，而FutureTask实现了Runnable接口。

  • 优点：线程只是实现Runnable或实现Callable接口，还可以继承其他类。这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
  • 缺点：编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。

4.使用线程池（Executor框架）

避免了频繁创建和销毁线程的开销。可以通过Executors类的静态方法创建不同类型的线程池。

  • 优点：线程池可以重用预先创建的线程，避免了线程创建和销毁的开销，显著提高了程序的性能。对于需要快速响应的并发请求，线程池可以迅速提供线程来处理任务，减少等待时间。并且，线程池能够有效控制运行的线程数量，防止因创建过多线程导致的系统资源耗尽（如内存溢出）。通过合理配置线程池大小，可以最大化CPU利用率和系统吞吐量。
  • 缺点：程池增加了程序的复杂度，特别是当涉及线程池参数调整和故障排查时。错误的配置可能导致死锁、资源耗尽等问题，这些问题的诊断和修复可能较为复杂。

怎么启动线程 ？

启动线程的通过Thread类的start()。

如何停止一个线程的运行?

  • 异常法停止：线程调用interrupt()方法后，在线程的run方法中判断当前对象的interrupted()状态，如果是中断状态则抛出异常，达到中断线程的效果。
  • 在沉睡中停止：先将线程sleep，然后调用interrupt标记中断状态，interrupt会将阻塞状态的线程中断。会抛出中断异常，达到停止线程的效果
  • stop()暴力停止：线程调用stop()方法会被暴力停止，方法已弃用，该方法会有不好的后果：强制让线程停止有可能使一些请理性的工作得不到完成。
  • 使用return停止线程：调用interrupt标记为中断状态后，在run方法中判断当前线程状态，如果为中断状态则return，能达到停止线程的效果。

调用 interrupt 是如何让线程抛出异常的?

每个线程都一个与之关联的布尔属性来表示其中断状态，中断状态的初始值为false，当一个线程被其它线程调用 Thread.interrupt() 方法中断时，会根据实际情况做出响应。

  • 如果该线程正在执行低级别的可中断方法（如 Thread.sleep() 、 Thread.join() 或Object.wait() ），则会解除阻塞并抛出 InterruptedException 异常。
  • 否则 Thread.interrupt() 仅设置线程的中断状态，在该被中断的线程中稍后可通过轮询中断状态来决定是否要停止当前正在执行的任务。

Java线程的状态有哪些？

  • NEW：尚未启动的线程状态，即线程创建，还未调用start方法
  • RUNNABLE：就绪状态（调用start，等待调度）+正在运行
  • BLOCKED：等待监视器锁时，陷入阻塞状态
  • WAITING：等待状态的线程正在等待另一线程执行特定的操作（如notify）
  • TIMED_WAITING：具有指定等待时间的等待状态
  • TERMINATED：线程完成执行，终止状态

sleep 和 wait的区别是什么？

  • 所属分类的不同：sleep 是 Thread 类的静态方法，可以在任何地方直接通过 Thread.sleep() 调用，无需依赖对象实例。wait 是 Object 类的实例方法，这意味着必须通过对象实例来调用。

  • 锁释放的情况： Thread.sleep() 在调用时，线程会暂停执行指定的时间，但不会释放持有的对象锁。也就是说，在 sleep 期间，其他线程无法获得该线程持有的锁。 Object.wait() ：调用该方
    法时，线程会释放持有的对象锁，进入等待状态，直到其他线程调用相同对象的 notify() 或notifyAll() 方法唤醒它

  • 使用条件：sleep 可在任意位置调用，无需事先获取锁。 wait 必须在同步块或同步方法内调用（即线程需持有该对象的锁），否则抛出 IllegalMonitorStateException 。

  • 唤醒机制：sleep 休眠时间结束后，线程 自动恢复 到就绪状态，等待CPU调度。wait 需要其他线程调用相同对象的 notify() 或 notifyAll() 方法才能被唤醒。 notify() 会随机唤醒一个在该对象上等待的线程，而 notifyAll() 会唤醒所有在该对象上等待的线程。

sleep会释放cpu吗？

是的，调用 Thread.sleep() 时，线程会释放 CPU，但不会释放持有的锁。

当线程调用 sleep() 后，会主动让出 CPU 时间片，进入 TIMED_WAITING 状态。此时操作系统会触发调度，将 CPU 分配给其他处于就绪状态的线程。这样其他线程（无论是需要同一锁的线程还是不相关线程）便有机会执行。

sleep() 不会释放线程已持有的任何锁（如 synchronized 同步代码块或方法中获取的锁）。因此，如果有其他线程试图获取同一把锁，它们仍会被阻塞，直到原线程退出同步代码块。

blocked和waiting有啥区别

  • 触发条件:线程进入BLOCKED状态通常是因为试图获取一个对象的锁，但该锁已经被另一个线程持有。这通常发生在尝试进入synchronized块或方法时，如果锁已被占用，则线程将被阻塞直到锁可用。线程进入WAITING状态是因为它正在等待另一个线程执行某些操作。在这种状态下，线程将不会消耗CPU资源，并且不会参与锁的竞争。
  • 唤醒机制:当一个线程被阻塞等待锁时，一旦锁被释放，线程将有机会重新尝试获取锁。如果锁此时未被其他线程获取，那么线程可以从BLOCKED状态变为RUNNABLE状态。线程在WAITING状态中需要被显式唤醒。

所以，BLOCKED和WAITING两个状态最大的区别有两个：

  • BLOCKED是锁竞争失败后被被动触发的状态，WAITING是人为的主动触发的状态
  • BLCKED的唤醒时自动触发的，而WAITING状态是必须要通过特定的方法来主动唤醒

wait 状态下的线程如何进行恢复到 running 状态?

线程从 等待（WAIT） 状态恢复到 运行（RUNNING） 状态的核心机制是 通过外部事件触发或资源可用性变化，比如等待的线程被其他线程对象唤醒， notify() 和 notifyAll() 。

notify 选择哪个线程?

notify在源码的注释中说到notify选择唤醒的线程是任意的，但是依赖于具体实现的jvm。JVM有很多实现，比较流行的就是hotspot，hotspot对notofy()的实现并不是我们以为的随机唤醒,而是“先进先出”的顺序唤醒。

notify 和 notifyAll 的区别?

同样是唤醒等待的线程，同样最多只有一个线程能获得锁，同样不能控制哪个线程获得锁。

  • notify：唤醒一个线程，其他线程依然处于wait的等待唤醒状态，如果被唤醒的线程结束时没调用notify，其他线程就永远没人去唤醒，只能等待超时，或者被中断
  • notifyAll：所有线程退出wait的状态，开始竞争锁，但只有一个线程能抢到，这个线程执行完后，其他线程又会有一个幸运儿脱颖而出得到锁

不同的线程之间如何通信？

共享变量是最基本的线程间通信方式。多个线程可以访问和修改同一个共享变量，从而实现信息的传递。为了保证线程安全，通常需要使用 synchronized 关键字或 volatile 关键字。

如何停止一个线程？

在 Java 中，停止线程的正确方式是 通过协作式的逻辑控制线程终止，而非强制暴力终止（如已废弃的Thread.stop() ）。

  • 通过共享标志位主动终止:定义一个 可见的 状态变量，由主线程控制其值，工作线程循环检测该变量以决定是否退出
  • 线程中断机制:通过 Thread.interrupt() 触发线程中断状态，结合中断检测逻辑实现安全停止。
  • Future 取消任务:使用线程池提交任务，并通过 Future.cancel() 停止线程，依赖中断机制
  • 处理不可中断的阻塞操作:某些 I/O 或同步操作（如 Socket.accept() 、Lock.lock() ）无法通过中断直接响应。此时需结合资源关闭操作。比如，关闭 Socket 释放阻塞。

避免使用以下已废弃方法：

  • Thread.stop() ：暴力终止，可能导致状态不一致。
  • Thread.suspend() / resume() ：易导致死锁。