什么是Java并发编程？

Java并发编程是指在Java程序中使用多线程实现并发任务执行的一种编程方式。多线程实现可以充分发挥多核CPU的优势，提高程序的并发处理能力和性能。

Java中的并发编程常用类和接口

• Thread：线程类，是Java中用于创建和管理线程的类。
• Runnable：代表线程要执行的任务，可以作为Thread类的构造参数使用。
• Lock：代表一个可重入互斥锁，提供了比synchronized关键字更灵活的线程同步方式。
• Condition：代表一个条件变量，通常与Lock一起使用，提供了线程等待和通知的机制。
• CountDownLatch：一个同步工具，可以让一个或多个线程在等待一组操作完成之前一直等待。
• CyclicBarrier：又是一个同步工具，可以让一组线程互相等待，直到所有线程都到达了某个状态再继续执行。
• Semaphore：一种计数信号量，可以用来限制并发访问的资源数量。

Java中的并发编程实现方式

Java中的并发编程实现方式主要有两种：继承Thread类和实现Runnable接口。

继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务
    }
}

实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程要执行的任务
    }
}

并发编程示例1：使用Lock和Condition实现生产者消费者模型

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

public class ProducerConsumer {

    private LinkedList<Integer> buffer = new LinkedList<>();
    private int maxSize = 10;

    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public void produce() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == maxSize) {
                notFull.await();
            }
            int num = (int) (Math.random() * 100);
            buffer.add(num);
            System.out.println("Produced: " + num);
            notEmpty.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void consume() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == 0) {
                notEmpty.await();
            }
            int num = buffer.removeFirst();
            System.out.println("Consumed: " + num);
            notFull.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final ProducerConsumer pc = new ProducerConsumer();

        Thread producerThread = new Thread(() -> {
            try {
                while (true) {
                    pc.produce();
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                while (true) {
                    pc.consume();
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();

        producerThread.join();
        consumerThread.join();
    }
}

这个示例中，我们使用了Lock和Condition实现了一个简单的生产者消费者模型。

并发编程示例2：使用CountDownLatch实现并发任务的等待

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        Thread t1 = new Thread(() -> {
            System.out.println("Thread1 is running");
            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            System.out.println("Thread2 is running");
            latch.countDown();
        });

        Thread t3 = new Thread(() -> {
            System.out.println("Thread3 is running");
            latch.countDown();
        });

        t1.start();
        t2.start();
        t3.start();

        latch.await();

        System.out.println("All threads are finished");
    }
}

这个示例中，我们创建了一个CountDownLatch实例，并设置了初始计数器为3。然后启动3个线程，每个线程执行完毕后都会调用countDown()方法来减少计数器的值。最后在主线程中调用await()方法来等待所有线程执行完毕。当计数器的值为0时，await()方法会返回，程序继续执行。