[Java 并发控制和同步的机制]

目录

🍖🍖前言:

🍖(～￣▽￣)～ 介绍

🍖(～￣▽￣)～下面是一个示例代码，演示如何使用锁（synchronized关键字）实现并发控制和同步：

🍖(～￣▽￣)～使用读写锁和原子变量优化后的示例代码：

🍖(～￣▽￣)～使用信号量来优化代码的示例代码：

---

🍖🍖前言:

(～￣▽￣)～ 好简单明了的详细笔记

🍖(～￣▽￣)～ 介绍

• 锁（Lock）：Java中的锁机制包括synchronized关键字和Lock接口，可以保证同一时间只有一个线程可以访问共享资源。使用锁可以避免线程之间的数据竞争和不一致性，保证线程安全和程序的正确性。

• 信号量（Semaphore）：Java中的Semaphore类用于控制并发访问的数量，可以限制同时访问共享资源的线程数。通过设置Semaphore的初始值和调用acquire()、release()等方法可以实现并发控制和同步。

• 条件变量（Condition）：Java中的Condition接口可以用于在多线程之间进行通信和协调，可以实现线程的等待和唤醒操作。使用Condition时需要先获取对应的锁对象，然后使用await()、signal()、signalAll()等方法进行线程的等待和唤醒。

• 原子操作（Atomic）：Java中的Atomic包提供了一些原子操作类，例如AtomicInteger、AtomicLong等，可以保证对共享资源的操作是原子性的，从而避免线程之间的数据竞争和不一致性。
   

🍖(～￣▽￣)～下面是一个示例代码，演示如何使用锁（synchronized关键字）实现并发控制和同步：

public class LockExample {
    private static int counter = 0;
    private static final int NUM_THREADS = 10;
    private static final int NUM_INCREMENTS = 1000000;

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[NUM_THREADS];

        for (int i = 0; i < NUM_THREADS; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < NUM_INCREMENTS; j++) {
                    synchronized (LockExample.class) {
                        counter++; // 使用synchronized关键字实现并发控制和同步
                    }
                }
            });
            threads[i].start();
        }

        for (int i = 0; i < NUM_THREADS; i++) {
            threads[i].join(); // 等待所有线程完成
        }

        System.out.println("Counter: " + counter);
    }
}

上面的代码定义了一个静态变量counter，然后创建10个线程，每个线程对counter执行1000000次自增操作。在每次自增操作前，使用synchronized关键字获取LockExample类的锁对象，从而实现并发控制和同步。在main()方法中，等待所有线程完成后，输出最终的counter值。

需要注意的是，在使用Java的并发控制和同步机制时，需要注意线程安全和程序的正确性，避免线程之间的数据竞争和不一致性。同时，也需要根据实际情况来选择合适的机制和方法，以达到最佳的性能和效果。

🍖(～￣▽￣)～使用读写锁和原子变量优化后的示例代码：

1. 使用读写锁：在上面的代码中，我们使用了ReentrantLock类实现了互斥锁，可以保证多个线程对count变量的访问的互斥性和可靠性。但是，如果多个线程只是读取count变量的值，而不是修改它，那么使用互斥锁会导致性能的下降。这时可以使用读写锁，即ReentrantReadWriteLock类，它可以同时支持多个线程对count变量的读取，但只支持一个线程对count变量的修改。这样可以提高程序的并发性能。

2. 使用原子变量：在上面的代码中，我们使用了普通的int类型变量来实现计数器，需要使用锁机制来保证多个线程对count变量的访问的互斥性和可靠性。但是，Java提供了一些原子变量类，例如AtomicInteger类，可以直接使用原子操作来实现计数器，不需要使用锁机制。这样可以提高程序的并发性能。

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

public class LockDemo {
    private AtomicInteger count = new AtomicInteger(0);
    private ReadWriteLock lock = new ReentrantReadWriteLock();

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

    public int getCount() {
        lock.readLock().lock();
        try {
            return count.get();
        } finally {
            lock.readLock().unlock();
        }
    }
}

• 在上面的代码中，我们使用了ReentrantReadWriteLock类实现了读写锁，可以同时支持多个线程对count变量的读取，但只支持一个线程对count变量的修改。在increment()方法中，我们使用了incrementAndGet()方法直接对count变量进行原子操作，不需要使用锁机制。在getCount()方法中，我们使用了readLock()方法获取读锁，使用了unlock()方法释放读锁，从而保证了多个线程对count变量的读取的并发性和可靠性。同时，我们使用了AtomicInteger类来实现计数器，可以直接使用原子操作来实现计数器，不需要使用锁机制，从而提高了程序的并发性能。

🍖(～￣▽￣)～使用信号量来优化代码的示例代码：

 如果需要控制并发访问的数量，例如限制同时访问某个资源的线程数量，可以使用信号量来实现。

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

public class SemaphoreDemo {
    private AtomicInteger count = new AtomicInteger(0);
    private Semaphore semaphore = new Semaphore(10);

    public void increment() throws InterruptedException {
        semaphore.acquire();
        try {
            count.incrementAndGet();
        } finally {
            semaphore.release();
        }
    }

    public int getCount() {
        return count.get();
    }
}

• 上面的代码中，我们使用了Semaphore类实现了信号量，可以控制并发访问的数量。在increment()方法中，我们使用了acquire()方法获取信号量，使用了release()方法释放信号量，从而保证了多个线程对count变量的访问的并发性和可靠性。同时，我们使用了AtomicInteger类来实现计数器，可以直接使用原子操作来实现计数器，不需要使用锁机制，从而提高了程序的并发性能。