Java中的多线程同步：Lock、Condition、Semaphore

翻滚的胖子
2023-05-28 13:40:23
后端技术
Java Python

Java中的多线程同步：Lock、Condition、Semaphore

一、前言

多线程程序的同步化是实现高效程序设计的必备技能。在这个过程中，Java提供了多种同步方式，其中Lock、Condition、Semaphore是比较常用的同步方式。本文将详细介绍这三种同步方式的使用方法，并提供通俗易懂的代码案例，帮助编程小白快速入门。

二、Lock、Condition、Semaphore的基本概念

1. Lock

Lock是Java提供的一种同步方式，与传统的synchronized方式相比，它具有更精细的控制能力和更好的性能表现。Lock机制需要手动加锁和释放锁，因此需要慎重考虑锁的粒度。Lock的使用方法如下：

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 代码块
} finally {
    lock.unlock();
}

2. Condition

Condition是在Lock锁机制下的等待通知方式。与传统的synchronized机制下的wait/notify方法相比，Condition不需要像synchronized那样强制把等待线程和同步队列中的线程全部唤醒，从而提高了程序的性能。Condition的使用方法如下：

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
try {
    condition.await();
} finally {
    lock.unlock();
}

3. Semaphore

Semaphore是一种计数信号量，用于控制同时访问某个资源的线程数。Semaphore可以控制访问资源的线程数量，从而避免由于线程过多导致的资源过度竞争和拥堵问题。Semaphore的使用方法如下：

Semaphore semaphore = new Semaphore(2);
try {
    semaphore.acquire();
    // 代码块
} finally {
    semaphore.release();
}

三、Lock、Condition、Semaphore的应用场景

Lock、Condition、Semaphore的应用场景如下：

1. Lock、Condition

Lock、Condition可以用于解决多线程的死锁问题。在多线程程序中，如果线程之间的依赖关系设计不当，就会导致死锁。通过使用Lock、Condition，可以避免死锁问题的发生，并提高程序的性能。

2. Semaphore

Semaphore可以用于控制线程的并发数量。在高并发的场景下，使用Semaphore可以避免由于线程过多导致的资源过度竞争和拥堵问题，提高程序的性能。

四、Lock、Condition、Semaphore的代码案例

下面是Lock、Condition、Semaphore的代码案例，帮助大家更好地理解这三种同步方式的使用方法。

1. Lock、Condition

代码实现了两个线程之间的依赖关系，如果线程2没有得到线程1的结果，就会一直等待。

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

public class LockTest {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean flag = false;

    public void print() {
        lock.lock();
        try {
            if (!flag) {
                condition.await();
            }
            System.out.println("Hello World!");
            flag = false;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print2() {
        lock.lock();
        try {
            if (flag) {
                condition.await();
            }
            System.out.println("Hello Java!");
            flag = true;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        new Thread(() -> {
            while (true) {
                lockTest.print();
            }
        }).start();
        new Thread(() -> {
            while (true) {
                lockTest.print2();
            }
        }).start();
    }
}

2. Semaphore

代码实现了多个线程对共享资源的访问，通过Semaphore机制可以控制同时访问资源的线程数量。

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    private Semaphore semaphore = new Semaphore(2);

    public void print() {
        try {
            semaphore.acquire();
            System.out.println("Hello World!");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }

    public static void main(String[] args) {
        SemaphoreTest semaphoreTest = new SemaphoreTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> semaphoreTest.print()).start();
        }
    }
}