【JAVA】Java高级：多线程与并发编程——线程同步与死锁

在Java编程中，线程是实现并发执行的基本单位。随着多核处理器的普及，线程的使用变得越来越普遍。然而，多线程编程也带来了许多挑战，其中最重要的就是线程同步和死锁问题。理解这些概念对于编写安全、高效的并发程序至关重要。

在实际应用中，线程同步的主要目的是保证多个线程在访问共享资源时的安全性。例如，在一个在线购物系统中，多个用户可能同时访问库存数据。如果没有适当的同步机制，可能会导致库存数量不准确，从而影响用户体验和系统的可靠性。

另一方面，死锁是一种特殊的状态，发生在两个或多个线程相互等待对方释放资源的情况下。死锁会导致程序停滞不前，因此了解如何识别和避免死锁对于开发高效的多线程应用程序是至关重要的。

线程同步

理论知识

线程同步是指在多线程环境中，确保多个线程对共享资源的访问是安全的。Java提供了多种机制来实现线程同步，最常用的包括：

1. synchronized关键字：用于修饰方法或代码块，确保同一时刻只有一个线程可以执行被修饰的代码。

2. Lock接口：提供了比synchronized更灵活的锁机制，允许更细粒度的锁控制。

3. volatile关键字：确保变量的可见性，适用于状态标志等场景。

示例：使用synchronized进行线程同步

class Counter {
    private int count = 0;

    // 使用synchronized修饰方法，确保线程安全
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        // 创建多个线程同时执行increment方法
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // 输出最终计数值
        System.out.println("Final count: " + counter.getCount());
    }
}

代码解释

1. Counter类：包含一个私有变量count和一个同步方法increment()，该方法在执行时会锁定Counter对象，确保同一时刻只有一个线程可以访问。

2. 主方法：创建两个线程t1和t2，每个线程都执行1000次increment()。通过调用join()方法，主线程等待这两个线程执行完毕。

3. 输出结果：最终输出count的值，确保其为2000，表明线程安全。

死锁

理论知识

死锁是指两个或多个线程在执行过程中，因为争夺资源而造成的一种相互等待的状态。在这种状态下，所有参与的线程都无法继续执行。死锁通常发生在以下四个条件同时满足时：

1. 互斥条件：至少有一个资源被一个线程占用。

2. 保持并等待：一个线程持有至少一个资源，并等待获取其他资源。

3. 不剥夺条件：已经分配给线程的资源在未使用完之前，不能被其他线程强行剥夺。

4. 循环等待：存在一个线程等待的资源形成一个环路。

示例：死锁的发生

class Resource {
    public synchronized void methodA(Resource other) {
        System.out.println(Thread.currentThread().getName() + " acquired " + this);
        try {
            // 模拟一些操作
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        other.methodB(this);
    }

    public synchronized void methodB(Resource other) {
        System.out.println(Thread.currentThread().getName() + " acquired " + this);
    }
}

public class DeadlockExample {
    public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();

        Thread t1 = new Thread(() -> resource1.methodA(resource2), "Thread-1");
        Thread t2 = new Thread(() -> resource2.methodA(resource1), "Thread-2");

        t1.start();
        t2.start();
    }
}

代码解释

1. Resource类：包含两个同步方法methodA()和methodB()。methodA()在获取当前对象的锁后，尝试获取另一个Resource对象的锁。

2. 主方法：创建两个Resource对象和两个线程t1和t2。t1试图获取resource1的锁并调用methodA(resource2)，而t2试图获取resource2的锁并调用methodA(resource1)。这导致两个线程互相等待对方释放锁，从而形成死锁。

3. 输出结果：由于发生了死锁，程序会停滞不前，无法继续执行。

避免死锁的策略

为了避免死锁，可以采用以下策略：

1. 资源有序分配：确保所有线程以相同的顺序请求资源。

2. 超时机制：设置线程在请求资源时的最大等待时间，超时则放弃。

3. **使用tryLock()**：使用Lock接口的tryLock()方法，尝试获取锁，如果获取失败则立即返回。

示例：避免死锁的实现

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Resource {
    private final Lock lock = new ReentrantLock();

    public void methodA(Resource other) {
        while (true) {
            // 尝试获取锁
            if (lock.tryLock()) {
                try {
                    System.out.println(Thread.currentThread().getName() + " acquired " + this);
                    // 模拟一些操作
                    Thread.sleep(100);
                    other.methodB(this);
                    break; // 成功执行后退出循环
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public void methodB(Resource other) {
        // 同样的逻辑
        System.out.println(Thread.currentThread().getName() + " acquired " + this);
    }
}

public class AvoidDeadlockExample {
    public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();

        Thread t1 = new Thread(() -> resource1.methodA(resource2), "Thread-1");
        Thread t2 = new Thread(() -> resource2.methodA(resource1), "Thread-2");

        t1.start();
        t2.start();
    }
}

代码解释

1. Resource类：使用ReentrantLock替代synchronized，并在methodA()中使用tryLock()方法尝试获取锁。如果获取失败，线程将继续尝试，直到成功为止。

2. 主方法：与之前的示例相同，但由于使用了tryLock()，即使两个线程同时运行，也不会发生死锁。

总结

在Java多线程编程中，线程同步和死锁是两个重要的概念。通过适当的同步机制，可以确保多个线程安全地访问共享资源。而通过理解死锁的形成原因和避免策略，可以有效地防止程序进入死锁状态。掌握这些理论知识和实践技巧，对于开发高效、可靠的Java应用程序至关重要。