多线程

线程有哪些状态

1. 新建状态（New） ：当新创建一个线程对象时，它处于新建状态。这意味着线程对象已经被创建，但尚未启动。
2. 就绪状态（Runnable） ：当线程对象创建后，并且其他线程调用了该对象的start()方法时，线程进入就绪状态。此时，线程位于“可运行线程池”中，等待获取CPU的使用权以执行程序代码。
3. 运行状态（Running） ：当就绪状态的线程获取了CPU时，它进入运行状态，开始执行程序代码。
4. 阻塞状态（Blocked） ：线程因某种原因放弃CPU使用权，暂时停止运行，就进入了阻塞状态。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况可分为以下几种：

• 等待阻塞：运行的线程执行wait()方法，释放占用的所有资源，进入等待状态。
• 同步阻塞：线程在获取对象的同步锁时，若该锁被其他线程占用，则进入同步阻塞状态。
• 其他阻塞：线程执行sleep()或join()方法，或发出I/O请求时，会进入阻塞状态。当sleep()状态超时、join()等待线程终止或超时、或I/O处理完毕时，线程重新转入就绪状态。

5. 终止状态（Dead） ：当线程执行完毕或因异常退出run()方法时，线程进入终止状态。线程一旦终止，就不能复生。

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

1. 所属对象和方法类型：

   • sleep()方法是Thread类中的静态方法，而wait()是Object类中的方法。这意味着任何对象都可以调用wait()方法，而sleep()方法只能由Thread对象调用。

2. 对锁的控制：

   • 在调用sleep()方法时，线程不会释放它持有的对象锁，即线程仍然占用该锁，其他线程无法访问。
   • 而当线程调用wait()方法时，它会释放对象锁，使得其他线程可以访问该对象。

3. 使用位置和唤醒条件：

   • sleep()方法可以在任何位置使用，它没有特定的使用范围限制。当指定的时间到后，线程会自动恢复运行，不需要其他线程唤醒。
   • wait()方法必须在同步方法或同步块中调用。它不会自行恢复运行，而是需要其他线程调用notify()或notifyAll()方法来唤醒等待队列中的线程。

4. 异常处理：

   • 调用sleep()方法时必须捕获InterruptedException异常。
   • 而wait(), notify(), 和 notifyAll()方法不需要捕获异常。

5. 用途：

   • sleep()方法常用于使线程暂停执行一段指定的时间，期间线程不释放任何锁，并且不涉及线程间的通信。
   • wait()方法则主要用于线程间的交互和通信。它使线程放弃对象锁并进入等待状态，直到其他线程调用notify()或notifyAll()来唤醒它。

notify()和 notifyAll()有什么区别

1. 唤醒数量：

   • notify()方法只会随机唤醒等待队列中的一个线程，让它退出wait状态并进入就绪状态，等待获取对象的锁。
   • notifyAll()方法则会唤醒等待队列中的所有线程，使它们全部退出wait状态并进入就绪状态，等待获取对象的锁。

2. 调用方式：

   • notify()和notifyAll()方法都必须在同步代码块中调用，并且必须包含在synchronized块中。调用这两个方法的对象必须是该同步代码块的监视器对象，并且只有在获取了对象的锁之后才能调用。如果调用时不持有锁，会抛出IllegalMonitorStateException异常。

3. 竞争情况：

   • 由于notify()方法只唤醒一个线程，这可能导致某些线程长时间等待或一直处于等待状态，甚至引发死锁的情况。这是因为每次只有一个线程被唤醒，如果它无法获取锁或无法完成其任务，其他线程将继续等待。
   • notifyAll()方法唤醒所有等待的线程，使它们都有机会竞争锁，从而减少了线程长时间等待或死锁的可能性。

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

1. 执行方式：

   • run()方法：当直接调用线程的run()方法时，它会在当前线程中直接执行，并不会创建一个新的线程。这意味着run()方法就像一个普通的Java方法一样运行。
   • start()方法：当调用线程的start()方法时，它会启动一个新的线程来执行run()方法中的代码。这是Java中实现多线程的主要方式。

2. 线程状态：

   • 调用run()方法时，线程并不会从新建状态转变为就绪状态，也不会获取CPU的执行权。
   • 调用start()方法会使线程由新建状态转变为就绪状态，等待CPU的调度执行。

3. 重复调用：

   • run()方法可以被重复调用，每次调用都会在当前线程中执行run()中的代码。
   • start()方法不能被重复调用。一旦线程启动（即start()方法被调用），再次调用start()会抛出IllegalStateException异常。

4. 异常处理：

   • 当run()方法中的代码抛出异常时，该异常会在当前线程中处理，并不会影响其他线程的执行。
   • start()方法本身不会抛出异常，但是新线程在执行run()方法时可能会抛出异常，这需要根据具体情况进行处理。

5. 返回值：

   • run()方法的返回类型必须是void，因为它不能返回任何值给调用它的线程。
   • start()方法没有返回值。

多线程锁的升级原理是什么 多线程锁的升级原理主要涉及到Java虚拟机（JVM）对synchronized关键字优化的过程。在Java中，synchronized关键字最初实现的是一种重量级锁，这种锁在竞争激烈的情况下性能较低，因为它涉及到线程的挂起和唤醒，这些操作相对消耗系统资源。

为了提升性能，JVM对synchronized的运行机制进行了优化，引入了锁的升级机制。这种机制会根据线程访问共享资源的竞争状态，自动切换到合适的锁级别。从低到高，锁的级别依次为：无锁、偏向锁、轻量级锁和重量级锁。

1. 无锁状态：当对象刚刚被实例化，还没有任何线程来访问它时，它处于无锁状态。
2. 偏向锁：当第一个线程访问对象时，JVM会尝试将这个锁偏向给这个线程。偏向锁是一种乐观锁，它认为在大多数情况下，只有一个线程会访问这个对象。偏向锁通过CAS（Compare-and-Swap）操作将对象头中的ThreadID改为访问线程的ID，这样后续这个线程访问该对象时，只需要对比ID，无需再进行CAS操作。如果对象长时间未被线程访问，或者发生了其他线程竞争锁的情况，偏向锁可能会被撤销，对象回到无锁状态。
3. 轻量级锁：当第二个线程尝试访问已经被偏向锁锁定的对象时，偏向锁会升级为轻量级锁。轻量级锁也是一种乐观锁，它认为尽管存在竞争，但竞争的程度较轻。线程会尝试通过自旋（busy-waiting）的方式获取锁，而不会立即阻塞。如果自旋超过一定的次数，或者当前已有一个线程持有锁，而另一个线程在自旋等待，此时又有第三个线程来访，轻量级锁会升级为重量级锁。
4. 重量级锁：当轻量级锁无法有效处理竞争时，锁会升级为重量级锁。重量级锁是一种悲观锁，它认为竞争很激烈，因此除了拥有锁的线程以外的线程都会被阻塞，防止CPU空转。

什么是死锁 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

死锁具有如下几个特点：

1. 占有一定的资源，等待对方释放资源。
2. 获得对方资源前不释放自己占有的资源。

死锁的发生通常与资源分配策略不当或程序员编写的程序存在错误有关。例如，当两个线程或进程都成功获取到第一个锁，但都在等待对方释放第二个锁时，就会发生死锁。此外，系统资源不足、进程运行推进顺序不合适以及资源分配不当等因素也可能导致死锁的发生。