Java学习指南-第十六天：并发编程

　　1.并发编程简介

　　并发编程是指在同一时间内处理多个任务的能力。Java提供了丰富的API来支持并发编程，包括线程、线程池、同步工具等。

　　2.线程

　　线程是并发编程的基本单位。Java中的线程可以通过继承Thread类或实现Runnable接口来创建。

　　2.1创建线程

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

　　2.2实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

　　3.线程池

　　线程池是管理多个线程的机制，可以有效地控制线程的创建和销毁。Java提供了ExecutorService接口和Executors工具类来支持线程池。

　　3.1使用线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            Runnable task = new MyRunnable();
            executor.execute(task);
        }

        executor.shutdown();
    }
}

　　4.同步工具

　　Java提供了多种同步工具来协调多个线程的执行，如CountDownLatch、CyclicBarrier、Semaphore等。

　　4.1 CountDownLatch

　　CountDownLatch用于等待一组线程完成后再执行某个任务。

import java.util.concurrent.CountDownLatch;

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

        for (int i = 0; i < n; i++) {
            new Thread(() -> {
                System.out.println("Thread is running");
                latch.countDown();
            }).start();
        }

        latch.await();
        System.out.println("All threads have finished");
    }
}

　　4.2 CyclicBarrier

　　CyclicBarrier用于等待一组线程到达某个屏障点后再继续执行。

import java.util.concurrent.CyclicBarrier;

public class Main {
    public static void main(String[] args) {
        int n = 3;
        CyclicBarrier barrier = new CyclicBarrier(n, () -> {
            System.out.println("All threads have reached the barrier");
        });

        for (int i = 0; i < n; i++) {
            new Thread(() -> {
                System.out.println("Thread is running");
                try {
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

　　4.3 Semaphore

　　Semaphore用于控制同时访问某个资源的线程数量。

import java.util.concurrent.Semaphore;

public class Main {
    public static void main(String[] args) {
        int permits = 2;
        Semaphore semaphore = new Semaphore(permits);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread is running");
                    Thread.sleep(1000);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

　　5.今日任务

　　使用线程池执行一组任务，并等待所有任务完成。

　　使用CountDownLatch等待一组线程完成后再执行某个任务。

　　使用Semaphore控制同时访问某个资源的线程数量。

　　6.示例代码

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 任务1：使用线程池执行一组任务
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            Runnable task = () -> System.out.println("Task is running");
            executor.execute(task);
        }
        executor.shutdown();

        // 任务2：使用CountDownLatch等待一组线程完成
        int n = 3;
        CountDownLatch latch = new CountDownLatch(n);
        for (int i = 0; i < n; i++) {
            new Thread(() -> {
                System.out.println("Thread is running");
                latch.countDown();
            }).start();
        }
        latch.await();
        System.out.println("All threads have finished");

        // 任务3：使用Semaphore控制同时访问某个资源的线程数量
        int permits = 2;
        Semaphore semaphore = new Semaphore(permits);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread is running");
                    Thread.sleep(1000);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}