关于Java多线程的一些随笔

Synchronized与ReentrantLock有哪些相同点和不同点？

在Java中，synchronized关键字和ReentrantLock类都用于管理线程间的同步，但它们在实现方式、功能和灵活性方面存在一些差异。以下是它们的相同点和不同点：

相同点

互斥性：synchronized和ReentrantLock都提供了线程互斥的机制，确保在同一时间只有一个线程可以执行特定代码段。
防止线程干扰：它们都用于解决线程安全问题，避免多线程环境下的数据不一致性和竞争条件。
可重入性：这两种机制都是可重入的，即同一个线程可以多次获取已经持有的锁。
锁定代码块或对象：它们都可以锁定代码块或整个方法，以保护关键部分的代码不被多线程同时执行。

不同点

实现方式：
- synchronized是Java的内置关键字，其实现是隐藏的，用户无需手动管理锁的获取和释放。
- ReentrantLock是Java标准库中的API，需要显式地创建锁对象，显式地获取和释放锁。
功能特性：
- ReentrantLock提供了比synchronized更多的功能，如可中断的锁获取、尝试非阻塞地获取锁（tryLock()）、设置公平锁等。
- synchronized不支持这些高级特性。
条件变量：
- ReentrantLock与Condition对象配合，可以分别控制线程的等待和唤醒，这为线程间通信提供了更多的灵活性。
- synchronized则是配合Object类的wait()、notify()和notifyAll()方法来实现线程间的通信。
锁的公平性：
- ReentrantLock允许用户选择是使用公平锁还是非公平锁。
- synchronized不保证公平性，没有提供公平锁的选项。
性能和优化：
- 在Java 6及以后版本中，synchronized的性能得到了显著提升，尤其在低至中等线程竞争的情况下。
- ReentrantLock可能在高竞争环境下表现更优，特别是在使用公平锁或者需要更复杂的条件同步时。
锁的可中断性：
- ReentrantLock允许在等待锁的过程中响应中断。
- synchronized块内的线程等待获得锁时不能被中断。

总结

虽然synchronized和ReentrantLock都用于实现线程同步，但ReentrantLock提供了更多的控制和灵活性，特别适用于更复杂的多线程场景。而synchronized由于其简单性，更适用于那些不需要高级功能和低至中等线程竞争的场景。选择哪一个取决于具体需求和使用场景。

想要线程停止有哪些方式？
在Java中，安全地停止线程是多线程编程中的一个常见需求。过去，Java提供了stop()方法来停止线程，但由于这种方法会导致线程立即停止，可能导致共享资源处于不一致状态或其他线程在等待锁时发生死锁，因此这个方法已被废弃。现在，有几种更安全和优雅的方法来停止一个线程：

1. 使用中断

调用线程的interrupt()方法：
- 在线程中断点（如sleep()、wait()、join()等）会抛出InterruptedException，可以捕获这个异常并优雅地结束线程。
- 线程可以通过检查中断标志（使用Thread.interrupted()或Thread.currentThread().isInterrupted()）来响应中断。

2. 使用标志

设置自定义标志：
- 在线程的运行方法中，使用一个自定义的布尔标志来控制循环或运行状态。
- 当需要停止线程时，外部代码可以设置这个标志为false。

3. 使用`Future.cancel()`（对于`ExecutorService`）

如果线程是通过ExecutorService提交的，可以使用Future对象来请求取消。
调用Future.cancel(true)将尝试取消任务的执行。如果任务已经开始，它将尝试中断线程。

4. 使用`volatile`变量

使用volatile关键字声明的变量确保所有线程都能看到变量的最新值。
可以使用一个volatile boolean变量作为一个信号，告诉线程何时停止。

代码示例

使用中断

public class MyThread extends Thread {
    public void run() {
        while (!Thread.interrupted()) {
            // 执行任务
        }
        // 清理资源并停止执行
    }
}

MyThread thread = new MyThread();
thread.start();
// 一段时间后
thread.interrupt();

使用自定义标志

public class MyThread extends Thread {
    private volatile boolean running = true;

    public void run() {
        while (running) {
            // 执行任务
        }
        // 清理资源并停止执行
    }

    public void stopRunning() {
        running = false;
    }
}

MyThread thread = new MyThread();
thread.start();
// 一段时间后
thread.stopRunning();

注意事项

不要使用Thread.stop()方法停止线程，因为它是不安全的。
始终确保线程的停止操作是安全的，不会导致资源泄露或状态不一致。

总之，正确停止线程的关键在于提供一种机制，使线程可以在完成当前工作后安全地终止，而不是强行从外部中断其执行。

哪些方式会造成线程死锁？
在Java中，线程死锁通常发生在两个或多个线程永久性地阻塞对方，等待对方释放锁，从而无法继续执行。造成死锁的主要原因通常涉及一组互相竞争资源的线程，这些线程彼此之间因为锁的竞争而无法前进。以下是一些可能导致线程死锁的常见情况：

1. 锁顺序死锁

当两个或多个线程以不同的顺序获取相同的锁时，可能会发生死锁。例如，线程A持有锁L1并试图获取锁L2，同时线程B持有锁L2并试图获取锁L1。

2. 循环等待

当两个或多个线程形成一个循环等待链时，每个线程都在等待链中的下一个线程释放锁。这是造成死锁的一个典型模式。

3. 资源死锁

线程对多个资源的需求可能导致死锁。例如，线程A等待线程B持有的资源，而线程B等待线程A持有的资源。

4. 嵌套锁

当一个线程在持有一个锁的同时尝试获取另一个锁时，如果其他线程以相反的顺序尝试获取这些锁，就可能产生死锁。

5. 不可中断的操作

线程可能在等待一个不可中断的资源（例如I/O操作）时阻塞，如果其他线程需要等待这个阻塞线程释放的资源，也可能导致死锁。

代码示例

public class DeadlockDemo {
    private static final Object Lock1 = new Object();
    private static final Object Lock2 = new Object();

    public static void main(String args[]) {
        ThreadDemo1 T1 = new ThreadDemo1();
        ThreadDemo2 T2 = new ThreadDemo2();
        T1.start();
        T2.start();
    }

    private static class ThreadDemo1 extends Thread {
        public void run() {
            synchronized (Lock1) {
                System.out.println("Thread 1: Holding lock 1...");

                try { Thread.sleep(10); }
                catch (InterruptedException e) {}

                System.out.println("Thread 1: Waiting for lock 2...");
                synchronized (Lock2) {
                    System.out.println("Thread 1: Holding lock 1 & 2...");
                }
            }
        }
    }

    private static class ThreadDemo2 extends Thread {
        public void run() {
            synchronized (Lock2) {
                System.out.println("Thread 2: Holding lock 2...");

                try { Thread.sleep(10); }
                catch (InterruptedException e) {}

                System.out.println("Thread 2: Waiting for lock 1...");
                synchronized (Lock1) {
                    System.out.println("Thread 2: Holding lock 1 & 2...");
                }
            }
        }
    }
}

在这个示例中，ThreadDemo1 和 ThreadDemo2 分别尝试以不同的顺序获取 Lock1 和 Lock2，这可能导致死锁。

避免死锁的策略

锁顺序：确保所有线程以相同的顺序获取锁。
锁超时：使用带有超时的锁获取机制，如tryLock()。
死锁检测：在系统设计中实现死锁检测机制，并相应地采取措施。
减少锁的使用：尽可能减少同步块的使用，避免不必要的锁。
使用并发工具类：利用Java的java.util.concurrent包中的并发工具类，如ReentrantLock，它们提供了更灵活的锁定机制。

sleep,wait,yield,join的区别?

在Java中，sleep(), wait(), yield(), 和 join() 是用于控制线程行为的重要方法，它们在多线程编程中有着各自的作用和特性。理解它们之间的区别对于编写有效的多线程代码非常重要。

1. `sleep()`

所属类：Thread类
目的：使当前执行的线程暂停执行指定的时间（给定的毫秒数），不释放任何锁。
使用场景：暂停线程执行一段时间，不涉及锁资源的释放或等待。

2. `wait()`

所属类：Object类
目的：使当前线程进入等待状态直到另一个线程调用相同对象的notify()或notifyAll()方法。在调用wait()时，线程必须持有该对象的锁，调用后会释放这个对象的锁。
使用场景：线程需要等待特定条件的满足，并在等待期间释放对象锁以允许其他线程修改这个条件。

3. `yield()`

所属类：Thread类
目的：使当前线程让出CPU执行时间，但不释放任何锁资源。yield()的调用不会导致线程状态的改变，它只是建议线程调度器当前线程愿意放弃当前的CPU资源，但线程调度器可以自由忽略这个提示。
使用场景：当一个线程认为自己不那么重要，或者希望给予其他相同优先级的线程执行机会时。

4. `join()`

所属类：Thread类
目的：等待调用join()方法的线程结束。换句话说，假设在线程A中调用了线程B的join()方法，线程A将会被挂起，直到线程B完成执行后才会继续执行。
使用场景：当一个线程需要等待另一个线程完成工作之后再继续执行。

比较

锁的释放：
- wait()方法在等待时会释放锁，而sleep()和yield()不会释放任何锁。
- join()方法不涉及锁的概念，但它会使调用者等待直到目标线程完成。
控制精度：
- sleep()可以精确地控制需要暂停的时间。
- wait()通常用于线程间的交互和条件等待，依赖于外部因素来唤醒。
- yield()对于线程调度的影响不确定，取决于具体的线程调度器的实现。
- join()用于等待另一个线程完成，其等待时间取决于目标线程的执行时间。
异常处理：
- sleep(), wait(), 和 join() 都会抛出InterruptedException，这表明线程的等待、睡眠或占用状态被中断了。
- yield()不会抛出InterruptedException。

理解这些方法的不同之处有助于更好地利用Java的多线程机制，并编写出更有效、更稳定的并发应用程序。

zhuhai0613