Java中的多线程并发控制

一、引言

在现代计算机系统中，多核处理器已经成为标配，为了充分利用多核处理器的性能优势，程序需要采用多线程技术来实现并发执行。Java作为一种广泛使用的编程语言，提供了丰富的多线程支持。然而，多线程编程并非易事，尤其是在处理共享资源时，需要考虑线程安全问题。本文将详细介绍Java中的多线程并发控制方法。

二、synchronized关键字

在Java中，最基本的线程同步方法是使用synchronized关键字。它可以用于修饰方法或者作为代码块。当一个线程获得对象的锁时，其他线程将无法进入该对象的synchronized方法或代码块，直到锁被释放。

示例代码：

class SynchronizedExample {
   
    private int count = 0;

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

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

三、Lock接口

除了synchronized关键字外，Java还提供了更灵活的线程同步机制——Lock接口。与synchronized相比，Lock接口提供了更多的功能，如可中断等待、公平锁等。常见的实现类有ReentrantLock。

示例：

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

class LockExample {
   
    private int count = 0;
    private final Lock lock = new ReentrantLock();

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

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

四、Semaphore类

Semaphore类是Java提供的一种计数信号量，可以用来控制同时访问特定资源的线程数量。Semaphore维护了一个许可集合，线程可以通过acquire()方法获取许可，通过release()方法释放许可。

示例代码：

import java.util.concurrent.Semaphore;

class SemaphoreExample {
   
    private int[] buffer = new int[10];
    private final Semaphore semaphore = new Semaphore(5);

    public void producer() {
   
        try {
   
            semaphore.acquire();
            buffer[buffer.length - 1] = (int) (Math.random() * 100);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            semaphore.release();
        }
    }

    public void consumer() {
   
        try {
   
            semaphore.acquire();
            int value = buffer[0];
            System.out.println("Consumed: " + value);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            semaphore.release();
        }
    }
}

五、CountDownLatch类

CountDownLatch类是Java提供的一种同步辅助类，它允许一个或多个线程等待其他线程完成操作。CountDownLatch通过一个计数器来实现这个功能，计数器的值只能递减。当计数器的值减为0时，等待的线程将被唤醒。

示例代码：

import java.util.concurrent.CountDownLatch;

class CountDownLatchExample {
   
    private static final int N = 10;
    private final CountDownLatch latch = new CountDownLatch(N);

    public void worker() {
   
        try {
   
            Thread.sleep((long) (Math.random() * 100));
            System.out.println("Worker finished");
            latch.countDown();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
    }

    public void awaitCompletion() {
   
        try {
   
            latch.await();
            System.out.println("All workers have finished");
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
    }
}

六、总结

本文介绍了Java中的多线程并发控制方法，包括synchronized关键字、Lock接口、Semaphore类和CountDownLatch类。这些方法可以帮助我们更好地处理多线程环境下的共享资源访问问题，提高程序的并发性能。在实际开发中，我们需要根据具体需求选择合适的同步机制，以确保线程安全。