java控制并发

原创

mob64ca12d9e536 2024-04-07 05:04:04 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d9e536的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java控制并发

并发是指计算机系统中同时执行多个独立的任务。在Java中，多线程是实现并发的一种常见方式。但是，多线程可能会引起资源竞争、死锁等问题。因此，Java提供了一些机制来控制并发，保证多线程之间的协调和同步。

同步机制

在多线程环境下，多个线程可能会同时访问共享资源，导致数据不一致或者出现意外结果。为了解决这个问题，Java提供了同步机制，最常见的就是synchronized关键字。

public class SynchronizedExample {
    private int count = 0;

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

在上面的示例中，通过synchronized关键字修饰的方法能够保证在同一时刻只有一个线程可以执行该方法，从而避免了资源竞争的问题。

锁机制

除了synchronized关键字之外，Java还提供了Lock接口和ReentrantLock类来实现锁机制。相比于synchronized关键字，Lock接口提供了更细粒度的控制，可以实现更加灵活的并发控制。

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

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

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

在上面的示例中，通过ReentrantLock类创建一个锁对象，并在需要同步的代码块中调用lock()和unlock()方法来实现线程的同步。

信号量

除了锁机制之外，Java还提供了Semaphore类来实现信号量控制。信号量是一种允许多个线程同时访问临界区的同步机制，可以控制同时访问的线程数量。

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private int count = 0;
    private Semaphore semaphore = new Semaphore(1);

    public void increment() {
        try {
            semaphore.acquire();
            count++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

在上面的示例中，通过Semaphore类创建一个信号量对象，然后在需要同步的代码块中调用acquire()和release()方法来实现线程的同步。

流程图

flowchart TD
    Start --> Input
    Input --> Process
    Process --> Decision
    Decision --Yes--> Lock
    Decision --No--> Semaphore
    Lock --> Output
    Semaphore --> Output
    Output --> End

代码示例

public class ConcurrencyControl {
    public static void main(String[] args) {
        SynchronizedExample synchronizedExample = new SynchronizedExample();
        LockExample lockExample = new LockExample();
        SemaphoreExample semaphoreExample = new SemaphoreExample();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronizedExample.increment();
                lockExample.increment();
                semaphoreExample.increment();
            }).start();
        }

        System.out.println("Synchronized count: " + synchronizedExample.getCount());
        System.out.println("Lock count: " + lockExample.getCount());
        System.out.println("Semaphore count: " + semaphoreExample.getCount());
    }
}