Java多线程之多种锁和阻塞队列

前言

在Java语言中，多线程编程经常涉及到线程的同步和互斥操作，为了实现这些操作，需要使用各种不同的锁和阻塞队列。本文将介绍Java多线程中几种常见的锁和阻塞队列的使用方法，并给出相应的示例说明。

可重入锁（ReentrantLock）

可重入锁是一种可重入的互斥锁，可以使线程在获得锁的情况下，多次调用同步方法而不产生死锁。可重入锁实现了java.util.concurrent.locks.Lock接口，与synchronized关键字相比，可重入锁具有更加灵活的控制能力，例如尝试获得锁的超时时间、可中断的锁等待等。

使用可重入锁需要使用lock()方法获得锁，使用unlock()方法释放锁。下面给出一个示例：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " get lock");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " unlock");
                lock.unlock();
            }
        }).start();
    }
}

上述示例中，我们使用可重入锁实现了一个线程等待另一个线程执行完毕的操作。在一个线程中，首先通过lock.lock()获取了可重入锁，然后在try块中执行了需要同步的操作，最终通过lock.unlock()释放了锁。

读写锁（ReadWriteLock）

读写锁是一种特殊的锁，它允许多个线程同时读取一个共享的资源，但只允许一个线程写入该共享资源。读写锁可以有效地提高对共享资源的访问效率和并发性，使得读线程和写线程可以同时执行，从而提升程序的性能。

使用读写锁需要使用ReadWriteLock接口，该接口包含了读锁和写锁两种锁，具体实现类为ReentrantReadWriteLock。下面给出一个示例：

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

public class ReadWriteLockExample {
    public static void main(String[] args) {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        new Thread(() -> {
            lock.readLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + " read lock");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " read unlock");
                lock.readLock().unlock();
            }
        }).start();

        new Thread(() -> {
            lock.writeLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + " write lock");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " write unlock");
                lock.writeLock().unlock();
            }
        }).start();
    }
}

上述示例中，我们使用读写锁实现了对共享资源的读写操作。在一个线程中，首先通过lock.readLock().lock()或lock.writeLock().lock()获取了读锁或写锁，然后在try块中执行了需要同步的操作，最终通过lock.readLock().unlock()或lock.writeLock().unlock()释放了锁。可以看到，读线程和写线程可以同时执行，从而提升了程序的性能。

阻塞队列（BlockingQueue）

阻塞队列是一种线程安全的队列，它提供了阻塞的插入和移除方法，可以很好地解决生产者-消费者问题。阻塞队列一般用于实现任务队列，可以在多线程环境下实现任务的异步执行。

Java中提供了多种阻塞队列的实现，例如ArrayBlockingQueue、LinkedBlockingQueue等等。下面给出一个示例：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    queue.put(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Thread.sleep(1000);

        for (int i = 1; i <= 10; i++) {
            System.out.println(queue.take());
        }
    }
}

上述示例中，我们使用ArrayBlockingQueue实现了一个生产者-消费者模型。在一个线程中，首先通过queue.put(i)阻塞地插入了10个整数，然后在另一个线程中通过queue.take()阻塞地获取队列中的元素，从而实现了任务的异步执行。

总结

Java提供了多种不同的锁和阻塞队列的实现，开发人员可以根据具体情况选择合适的锁和队列。在多线程编程过程中，合理使用锁和阻塞队列可以提高程序的并发性和健壮性。