Java互斥锁|极客教程

Java互斥锁

在多线程编程中，互斥锁是一种用于在多个线程中对共享资源进行同步访问的机制。Java中的互斥锁可以通过synchronized关键字或者ReentrantLock类来实现。在本文中，我们将详细介绍Java中互斥锁的概念、用法和实例。

互斥锁概念

互斥锁（Mutual Exclusion Lock）是一种同步机制，用于保护共享资源，使得在任意时刻只有一个线程可以访问该资源，避免多个线程同时对同一资源进行操作而引发数据不一致的情况。通过使用互斥锁，我们可以实现线程间的协同操作，确保线程安全性。

在Java中，主要有两种方式来实现互斥锁：

使用synchronized关键字：通过在方法或代码块中使用synchronized关键字来实现对共享资源的同步访问。
使用ReentrantLock类：通过ReentrantLock类提供的方法来实现更灵活的锁控制，包括可重入性、公平性等。

接下来，我们将分别介绍这两种方式的使用方法。

使用`synchronized`实现互斥锁

synchronized是Java中的关键字，用于实现对共享资源的同步访问。当一个线程进入synchronized代码块或方法时，其他线程将被阻塞，直到当前线程释放锁为止。下面是一个使用synchronized实现互斥锁的示例代码：

public class SynchronizedExample {

    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

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

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.decrement();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.getCount());
    }
}

在上面的示例中，我们创建了一个SynchronizedExample类，其中包含了increment和decrement方法用于对count变量进行加一和减一操作，这两个方法由synchronized关键字修饰，确保了对count的访问是互斥的。我们创建了两个线程分别调用increment和decrement方法，最后输出count的值。

使用`ReentrantLock`实现互斥锁

除了synchronized关键字，Java还提供了ReentrantLock类用于实现更加灵活的互斥锁控制。ReentrantLock类提供了更多的功能，如可重入性、公平性等。下面是一个使用ReentrantLock实现互斥锁的示例代码：

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

public class ReentrantLockExample {

    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();

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

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.decrement();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.getCount());
    }
}

在上面的示例中，我们创建了一个ReentrantLockExample类，其中包含了increment和decrement方法分别对count变量进行加一和减一操作，我们使用ReentrantLock来控制对count的访问，确保了线程的同步和互斥。