JUC并发编程详解

一、Atomic原子类

在并发编程中，我们常常需要对共享变量进行加锁以保证线程安全。在JDK 1.5版本中，引入了Atomic原子类，可以以一种线程安全的方式访问单个变量。其中最常用的类就是AtomicInteger，使用方式如下：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    
    private static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                int newVal = count.incrementAndGet();
                System.out.println("Thread 1: " + newVal);
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                int newVal = count.incrementAndGet();
                System.out.println("Thread 2: " + newVal);
            }
        });

        t1.start();
        t2.start();
    }
}

上述示例中，我们使用AtomicInteger来保证了count变量的线程安全性。在多线程场景下，我们可以使用incrementAndGet()方法来保证count的原子性加1。

二、Synchronized同步锁

在Java开发中，Synchronized是一种常用的同步机制。它可以在多线程环境下保证对共享资源的互斥访问。在使用Synchronized时，需要注意以下几点：

1、Synchronized可以作用于方法、代码块

public synchronized void testMethod() {
    // 方法内部代码
}

public void testMethod() {
    synchronized (this) {
        // 代码块
    }
}

2、Synchronized的锁是对象锁

在使用Synchronized时，我们需要明确哪个对象是锁，只有获取到锁的线程才能进入同步块进行访问。示例代码如下：

public class SynchronizedExample {

    private Object object = new Object();
    private int count = 0;

    public void addCount() {
        synchronized (object) {
            count++;
        }
    }

    public int getCount() {
        synchronized (object) {
            return count;
        }
    }

    // 省略其他方法
}

上述示例中，我们使用object对象作为锁，保证了count变量的线程安全性。

三、Semaphore信号量

Semaphore是一种计数信号量，用于控制访问资源的线程数量。它可以用来保护一个有限的资源，如线程池、IO流等。在Semaphore中，我们需要先定义信号量数量，然后在需要访问资源的线程中获取信号量，访问完毕后再释放信号量。示例代码如下：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    private Semaphore semaphore = new Semaphore(2);

    public void executeTask() {
        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + "获取了信号量，开始执行任务");
            Thread.sleep((long) (Math.random() * 5000));
            System.out.println(Thread.currentThread().getName() + "执行任务完成，释放信号量");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }

    // 省略其他方法
}

上述示例中，我们定义了一个Semaphore对象，使用它来保证并发线程不超过2个。在executeTask()方法中，我们通过semaphore.acquire()获取信号量，执行完毕后再通过semaphore.release()释放信号量。

四、CountDownLatch倒计时器

CountDownLatch是一种同步机制，它可以让线程等待其他线程完成操作后再继续执行。CountDownLatch的工作原理是通过一个计数器来实现的，计数器的初始值为线程的数量，每当一个线程完成操作后，计数器的值就减1，当计数器的值减到0时，所有等待的线程将继续执行。示例代码如下：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

    private CountDownLatch countDownLatch = new CountDownLatch(3);

    public void doTask() {
        try {
            System.out.println(Thread.currentThread().getName() + "开始执行任务");
            Thread.sleep((long) (Math.random() * 5000));
            System.out.println(Thread.currentThread().getName() + "执行任务完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }
    }

    public void waitTaskDone() {
        try {
            countDownLatch.await();
            System.out.println("所有任务执行完成！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 省略其他方法
}

上述示例中，我们定义了一个CountDownLatch对象，初始计数器值为3。在doTask()方法中，执行任务完成后，通过countDownLatch.countDown()来减少计数器的值。在waitTaskDone()方法中，通过countDownLatch.await()来等待所有线程完成操作。

五、ReentrantLock可重入锁

ReentrantLock是一种可重入锁，可以进行重复加锁，最常用的操作是使用lock()方法来获取锁，在使用完毕后再通过unlock()方法释放锁。使用ReentrantLock还可以配合Condition来实现线程等待和线程唤醒的机制。示例代码如下：

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

public class ReentrantLockExample {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private int count = 0;

    public void addCount() {
        try {
            lock.lock();
            count++;
            System.out.println(Thread.currentThread().getName() + "获得锁，count值增加为" + count);
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void subCount() {
        try {
            lock.lock();
            while (count <= 0) {
                condition.await();
            }
            count--;
            System.out.println(Thread.currentThread().getName() + "获得锁，count值减少为" + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // 省略其他方法
}

上述示例中，我们使用lock()方法获取锁，并在使用完毕后通过unlock()方法释放锁。在addCount()方法中，我们使用signalAll()方法来唤醒等待线程。在subCount()方法中，我们使用await()方法来等待条件满足并获取锁。