Java笔试面试题AI答之线程（16）

91. 简述java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

Java中实现线程的方法

在Java中，实现一个线程主要有两种方式：

1. 继承Thread类：
   通过创建一个类继承自java.lang.Thread类，并重写其run()方法，然后创建该类的实例，并调用实例的start()方法来启动线程。start()方法会调用run()方法，但是直接调用run()方法并不会启动新线程，而是在当前线程中执行run()方法。

2. 实现Runnable接口：
   通过创建一个类实现java.lang.Runnable接口，并实现其run()方法，然后创建Thread类的实例，将实现了Runnable接口的类的实例作为构造器参数传递给Thread类的实例，最后调用Thread实例的start()方法来启动线程。这种方式的好处是，Java不允许多重继承，但是可以实现多个接口，因此使用Runnable接口的方式更加灵活。

同步方法的修饰关键字

同步方法可以使用synchronized关键字来修饰。synchronized关键字可以修饰方法，使得在同一时刻，只有一个线程可以执行该方法，从而保证了线程安全。synchronized方法会自动锁定当前实例（对于实例方法）或该类（对于静态方法）作为锁对象。

为什么不推荐使用stop()和suspend()方法

1. stop()方法：
   stop()方法会立即停止线程的执行，并释放线程所持有的所有锁。这种突然的中断可能导致资源无法正确释放（如文件描述符、数据库连接等），数据可能处于不一致的状态，甚至可能导致死锁等问题。因此，Java不推荐使用stop()方法，并已在后续版本中将其标记为过时（deprecated）。

2. suspend()和resume()方法：
   这两个方法分别用于暂停和恢复线程的执行。然而，它们的使用同样存在问题。suspend()会立即暂停线程的执行，但不会释放线程所占用的资源（如锁），这可能导致死锁。而resume()方法用于恢复被suspend()暂停的线程，但由于suspend()和resume()无法精确地控制线程的暂停和恢复，很容易导致程序逻辑混乱。因此，Java同样不推荐使用这两个方法，并已在后续版本中将其标记为过时。

总之，由于stop()、suspend()和resume()方法存在潜在的安全问题和不确定性，Java推荐使用更加安全和灵活的线程控制机制，如interrupt()方法、synchronized关键字、ReentrantLock等。

92. 当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

当一个线程进入一个对象的一个synchronized方法后，其他线程是否可以进入此对象的其它方法，取决于多个因素，主要包括方法是否也被synchronized修饰以及方法的类型（静态或非静态）。以下是详细分析：

1. 方法未被synchronized修饰

如果其他方法没有被synchronized关键字修饰，那么当一个线程进入一个对象的synchronized方法后，其他线程仍然可以进入这个未被synchronized修饰的方法。这是因为未被synchronized修饰的方法不会被锁定，多个线程可以同时执行这些方法。

2. 方法被synchronized修饰

如果其他方法也被synchronized修饰，那么情况就变得复杂了。具体能否进入取决于synchronized方法的类型（静态或非静态）以及当前线程持有的锁的类型。

静态方法

• 如果当前线程进入的是synchronized静态方法，那么它持有的是该类的锁（Class Lock）。在这种情况下，其他线程仍然可以进入该对象的非静态synchronized方法，因为这些方法持有的是对象锁（Object Lock），与类锁不同。但是，其他线程不能进入该类的其他静态synchronized方法，因为它们也需要类锁。
• 反之，如果当前线程进入的是非静态synchronized方法，那么它持有的是对象锁。此时，其他线程可以进入该类的静态synchronized方法，因为静态方法持有的是类锁，但无法进入该对象的其他非静态synchronized方法，因为它们也持有对象锁。

非静态方法

• 如果两个方法都是非静态的并且都被synchronized修饰，那么它们共享同一个对象锁。在这种情况下，当一个线程进入一个非静态synchronized方法后，其他线程将无法进入该对象的任何其他非静态synchronized方法，直到第一个线程释放锁。

3. 同步监视器的wait()方法

如果synchronized方法内部调用了同步监视器的wait()方法，那么其他线程有可能进入其他使用synchronized方法修饰的方法，但这取决于wait()方法的调用方式和上下文。wait()方法会释放当前线程持有的锁，并允许其他线程进入同步块或同步方法。然而，这并不意味着其他线程可以无条件地进入所有synchronized方法，因为还需要考虑锁的类型和方法的类型。

总结

综上所述，当一个线程进入一个对象的一个synchronized方法后，其他线程是否可以进入此对象的其它方法取决于多个因素，包括方法是否被synchronized修饰、方法的类型（静态或非静态）以及是否调用了同步监视器的wait()方法等。在设计和实现多线程程序时，需要仔细考虑这些因素以确保程序的正确性和性能。

93. 简述请说出你所知道的线程同步的方法 ？

线程同步是并发编程中的一个重要概念，它用于控制多个线程对共享资源的访问，以避免数据不一致和竞争条件等问题。我所知道的线程同步方法主要包括以下几种：

1. 临界区（Critical Section）

• 定义：临界区是一种通过串行化访问公共资源或代码段的机制，以保证在同一时间内只有一个线程可以执行该段代码。
• 特点：速度快，适合控制数据访问。但只能用于同步本进程内的线程，不能跨进程使用。

2. 互斥量（Mutex）

• 定义：互斥量（也称为互斥锁）用于协调对共享资源的单独访问。互斥对象只有一个，只有拥有互斥对象的线程才具有访问资源的权限。
• 特点：
  • 能够在同一应用程序的不同线程或不同应用程序的线程之间实现资源的安全共享。
  • 互斥量可以命名，因此可以跨进程使用，但这也意味着创建互斥量需要更多的资源。
  • 当线程尝试获取已被其他线程持有的互斥量时，会被阻塞，直到互斥量被释放。

3. 信号量（Semaphore）

• 定义：信号量是一种计数器机制，用于控制对公共资源的访问。它允许多个线程在同一时刻访问同一资源，但需要限制在同一时刻访问此资源的最大线程数目。
• 特点：
  • 适用于控制具有有限数量用户资源的场景。
  • 信号量机制必须有公共内存，因此不能用于分布式操作系统。
  • 使用时对信号量的操作分散，难以控制，可能增加程序员的编码负担。

4. 事件（Event）

• 定义：事件用于通知线程某些事件已发生，从而启动后继任务的开始。
• 特点：
  • 通过通知操作的方式来保持线程的同步。
  • 可以实现不同进程中的线程同步操作。

5. 读写锁（Read-Write Lock）

• 定义：读写锁是另一种实现线程同步的方式，它将操作分为读、写两种方式。
• 特点：
  • 可以允许多个线程同时读取数据，但写操作是独占的。
  • 相较于互斥锁，读写锁具有更高的并发性，适用于读多写少的场景。

6. 等待/通知机制（Wait/Notify）

• 定义：通过wait()、notify()和notifyAll()方法实现的线程间通信和同步机制。
• 特点：
  • wait()方法使当前线程等待，并释放持有的锁。
  • notify()方法唤醒等待队列中的一个线程（由JVM决定）。
  • notifyAll()方法唤醒等待队列中的所有线程，让它们竞争锁。

7. 休眠（Sleep）

• 定义：sleep()方法使当前正在执行的线程暂停执行一段时间（毫秒）。
• 特点：
  • 是一个静态方法，调用时需要捕捉InterruptedException异常。
  • 不会释放锁，只是让线程暂停执行。

这些方法各有优缺点，适用于不同的场景和需求。在实际编程中，应根据具体情况选择合适的线程同步方法。

94. 简述synchronized和java.util.concurrent.locks.Lock的异同 ？

synchronized和java.util.concurrent.locks.Lock在Java中都是用于实现线程同步的机制，但它们在实现方式、灵活性和性能等方面存在一些异同。

相同点

• 功能相同：Lock接口能完成synchronized所能实现的所有功能，即都能保证同一时刻只有一个线程能访问被保护的代码块或方法。

不同点

1. 实现方式：

   • synchronized：是Java语言的一个关键字，是Java语言内置的特性，无法被继承或实现。它可以修饰方法或代码块，实现自动加锁和解锁。
   • Lock：是java.util.concurrent.locks包下的一个接口，需要显式地获取和释放锁，通常通过实现类（如ReentrantLock）来使用。

2. 灵活性：

   • synchronized：虽然提供了基本的同步功能，但其灵活性相对有限。例如，它不支持公平锁、尝试非阻塞地获取锁、可中断地获取锁以及超时获取锁等高级功能。
   • Lock：提供了比synchronized更灵活的同步控制。例如，ReentrantLock支持公平锁和非公平锁，提供tryLock()、lockInterruptibly()和tryLock(long timeout, TimeUnit unit)等方法，允许更复杂的同步策略。

3. 性能：

   • synchronized：在JDK 1.6及以后的版本中，synchronized的性能得到了显著提升，包括锁的升级、降级等优化。但在某些情况下，其性能可能仍然不如Lock。
   • Lock：由于Lock提供了更灵活的同步控制，因此在某些特定场景下（如需要尝试获取锁、可中断地获取锁等），其性能可能优于synchronized。

4. 锁的释放：

   • synchronized：会自动释放锁。无论是方法级的synchronized还是代码块级的synchronized，当方法或代码块执行完毕后，系统会自动释放锁。
   • Lock：必须手动释放锁。在使用Lock时，必须在finally块中释放锁，以确保在发生异常时也能正确释放锁，避免死锁。

5. 锁的粒度：

   • synchronized：锁的粒度相对较大，通常是一个对象或类的锁。这意味着，当一个线程获得了某个对象的锁后，其他线程就无法访问该对象上的其他synchronized代码块或方法，直到锁被释放。
   • Lock：提供了更细粒度的锁控制。例如，可以使用读写锁（ReadWriteLock）来允许多个线程同时读取数据，但只允许一个线程写入数据，从而提高了并发性能。

综上所述，synchronized和Lock各有优缺点，开发者应根据具体的应用场景和需求选择合适的同步机制。在需要简单同步且不需要复杂同步策略的场景下，可以使用synchronized；在需要更灵活、更高效的同步控制时，可以考虑使用Lock。

95. 简述如何停止一个正在运行的线程 ？

停止一个正在运行的线程是一个需要谨慎处理的问题，因为不恰当的停止方式可能会导致数据不一致、死锁或其他并发问题。在Java中，并没有直接的方法来立即停止一个线程（如C/C++中的pthread_kill或kill函数），但可以通过以下几种方式来实现线程的安全停止：

1. 使用中断（Interruption）：
   这是Java推荐的停止线程的方式。线程可以通过调用Thread.interrupt()方法来请求中断自己或其他线程。被中断的线程可以通过检查中断状态（通过Thread.currentThread().isInterrupted()或Thread.interrupted()方法）来决定是否响应中断。如果线程在阻塞状态（如调用Object.wait()、Thread.sleep()、Thread.join()等）中，中断会导致它抛出一个InterruptedException异常，从而允许线程提前退出阻塞状态并处理中断。

   注意，仅仅调用interrupt()并不会立即停止线程，它仅仅设置了一个中断状态，线程需要定期检查这个状态并作出响应。

2. 通过共享变量：
   可以定义一个共享变量作为线程停止的标志。线程在运行时定期检查这个变量的值，如果发现停止标志被设置，则线程可以安全地退出执行。这种方式需要线程主动检查停止标志，因此不如中断机制那样直接和及时。

3. 使用协作中断：
   协作中断是结合中断状态和共享变量的一种策略。线程在检查到中断状态被设置后，会尝试以一种协作的方式安全地停止其执行。这通常涉及到清理资源、释放锁、更新共享状态等操作，以确保线程安全地终止。

4. 避免使用已废弃的方法：
   如stop()、suspend()和resume()等方法，它们由于存在安全隐患，已被Java废弃。这些方法可能会导致线程在不安全的状态下停止或恢复执行，从而引发数据不一致、死锁等问题。

5. 使用volatile关键字：
   如果停止标志是一个共享变量，并且多个线程都会访问它，那么应该使用volatile关键字来修饰这个变量。volatile确保了变量的修改对所有线程立即可见，避免了由于编译器优化或缓存导致的可见性问题。

综上所述，使用中断机制是停止Java线程的最佳实践。通过中断和协作中断，可以优雅地处理线程的停止，同时保证数据的一致性和线程的安全性。

96. 简述notify()和notifyAll()有什么区别 ？

notify()和notifyAll()都是Java中用于多线程编程的方法，它们的主要区别在于唤醒等待线程的数量和方式。以下是两者的详细区别：

唤醒线程的数量

• notify()：此方法用于唤醒等待在特定对象上的一个随机线程。如果有多个线程在该对象上等待，那么notify()会随机选择一个线程进行唤醒，但无法确定具体是哪一个线程。
• notifyAll()：此方法用于唤醒等待在特定对象上的所有线程。这意味着所有在该对象上等待的线程都会被唤醒，并有机会重新进入同步代码块或方法以继续执行。

使用场景

• notify()：通常用于线程之间的竞争条件，其中只有一个线程能够获得资源或执行特定任务的情况。使用notify()时，需要更好的协调线程，以确保正确的处理。
• notifyAll()：适用于需要广播消息或在共享资源可用时唤醒所有等待线程的情况。使用notifyAll()时，需要更多的同步代码来协调线程，因为所有被唤醒的线程都会尝试重新进入同步代码块或方法。

线程安全性与性能

• 线程安全性：notifyAll()在唤醒所有线程时需要特别小心，因为如果有多个线程同时尝试进入同步代码块或方法，可能会导致数据的不一致性。相比之下，notify()在唤醒单个线程时更加安全。
• 性能：使用notifyAll()可能会导致更多的线程重新进入同步代码块或方法，这可能会消耗更多的CPU资源。相比之下，使用notify()可以更快地唤醒单个线程，因此可能在某些情况下提供更好的性能。

使用注意事项

• notify()和notifyAll()都必须在同步代码块或同步方法中调用，并且由持有该同步代码块或同步方法锁的线程调用。
• 调用notify()或notifyAll()时，不会立即释放锁，而是在当前线程退出同步代码块或同步方法时释放锁。被唤醒的线程在重新进入同步代码块或同步方法之前，需要再次获取锁。
• 如果在调用wait()的线程中没有其他线程调用notify()或notifyAll()，那么该线程将无限期地等待下去。

综上所述，选择使用notify()还是notifyAll()取决于具体的应用场景和需求。如果需要唤醒所有等待的线程，并且担心多个线程同时尝试进入同步代码块或方法的风险，那么使用notifyAll()可能是一个更好的选择。如果只需要唤醒一个线程，并且知道其他线程不会同时尝试进入同步代码块或方法，那么使用notify()可能是更好的选择。

答案来自文心一言，仅供参考