Java之线程篇六

Java 线程篇六：线程的安全性与锁机制

在多线程编程中，线程的安全性是一个必须重点关注的话题。由于多个线程可能会同时操作共享的数据，导致数据的不一致性和不可预知的错误，因此我们需要采取一些机制来保证线程的安全性。本节将重点讨论Java中提供的锁机制，包括内置锁、显式锁和读写锁，并通过代码示例进行说明。

1. 内置锁（Synchronized）

Java 提供了一种简单的同步机制，即使用 synchronized 关键字。它可以修饰方法或代码块，以确保同一时刻只有一个线程可以执行被保护的代码。

class Counter {
    private int count = 0;

    // 锁定整个方法
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) {
        Counter counter = new Counter();

        // 创建多个线程来增加计数
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

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

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

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

在上面的示例中，increment() 方法使用了 synchronized 修饰符，确保在同一时刻只能有一个线程执行此方法。最终的计数结果将是预期的20000，这是因为我们成功地避免了数据竞争。

2. 显式锁（ReentrantLock）

除了内置锁，Java 还提供了 ReentrantLock 类，这是一种显式锁，可以提供比内置锁更高级的功能，例如可中断的锁和公平性选择。

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 确保释放锁
        }
    }

    public int getCount() {
        return count;
    }
}

public class ReentrantLockExample {
    public static void main(String[] args) {
        Counter counter = new Counter();

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

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

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

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

在这个例子中，我们使用 ReentrantLock 来控制对共享变量 count 的访问。lock() 和 unlock() 方法确保了在对 count 进行操作时不会出现数据竞争。

3. 读写锁（ReadWriteLock）

在某些场景下，读操作比写操作频繁，我们可以使用 ReadWriteLock 来优化性能。在 ReadWriteLock 中，允许多个线程同时进行读，但写操作是互斥的。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class SharedData {
    private int data = 0;
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void setData(int data) {
        rwLock.writeLock().lock();
        try {
            this.data = data;
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    public int getData() {
        rwLock.readLock().lock();
        try {
            return data;
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

public class ReadWriteLockExample {
    public static void main(String[] args) {
        SharedData sharedData = new SharedData();

        Thread writer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                sharedData.setData(i);
                System.out.println("写入数据: " + i);
            }
        });

        Thread reader = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                int value = sharedData.getData();
                System.out.println("读取数据: " + value);
            }
        });

        writer.start();
        reader.start();
    }
}

在此示例中，我们使用 ReadWriteLock来区分读和写的操作，从而提高了并发性能。读线程可以并发执行，而写线程则是在写操作时独占锁。

总结

在Java的多线程编程中，线程安全是一个非常重要的话题，选择合适的锁机制可以有效避免数据竞争和提高程序的效率。内置锁（synchronized）、显式锁（ReentrantLock）以及读写锁（ReadWriteLock）都提供了不同层次和方式的同步控制，开发者可以根据具体的使用场景选择合适的锁机制。通过合理利用这些工具，我们能够编写出更安全、更高效的多线程程序。