Java_23_并发包

**Java23 并发包**

Java23 并发包是 Java 平台的一部分，提供了用于构建高性能、可伸缩的多线程应用程序的工具和类。该包包含了一系列的类和接口，帮助开发者管理并发性、线程安全性以及资源共享。

**1. 线程**

Java23 并发包中的 `Thread` 类是 Java 平台中所有线程的基类。每个线程都有自己的执行栈和程序计数器。

javapublic class MyThread extends Thread {
 @Override public void run() {
 System.out.println("Hello, world!");
 }

 public static void main(String[] args) {
 MyThread thread = new MyThread();
 thread.start(); // 启动线程 }
}

**2. 线程池**

Java23 并发包中的 `ThreadPoolExecutor` 类是线程池的实现类。线程池可以重用已经创建的线程，避免每次请求都创建一个新的线程。

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

public class MyThreadPool {
 public static void main(String[] args) {
 ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池 for (int i =0; i < 10; i++) {
 final int num = i;
 executor.submit(() -> System.out.println("Task " + num));
 }

 executor.shutdown(); // 关闭线程池 }
}

**3. 锁**

Java23 并发包中的 `Lock` 接口是用于实现锁的抽象类。锁可以用来保护共享资源，防止多个线程同时访问。

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

public class MyLock {
 private final Lock lock = new ReentrantLock();

 public void doSomething() {
 lock.lock(); // 加锁 try {
 System.out.println("Doing something...");
 } finally {
 lock.unlock(); // 解锁 }
 }

 public static void main(String[] args) {
 MyLock lock = new MyLock();
 lock.doSomething();
 }
}

**4.读写锁**

Java23 并发包中的 `ReentrantReadWriteLock` 类是用于实现读写锁的抽象类。读写锁可以用来保护共享资源，允许多个线程同时读取，而只允许一个线程写入。

javaimport java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyReadWriteLock {
 private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

 public void read() {
 lock.readLock().lock(); // 加读锁 try {
 System.out.println("Reading...");
 } finally {
 lock.readLock().unlock(); // 解读锁 }
 }

 public void write() {
 lock.writeLock().lock(); // 加写锁 try {
 System.out.println("Writing...");
 } finally {
 lock.writeLock().unlock(); // 解写锁 }
 }

 public static void main(String[] args) {
 MyReadWriteLock lock = new MyReadWriteLock();
 lock.read();
 lock.write();
 }
}

**5. 队列**

Java23 并发包中的 `BlockingQueue` 接口是用于实现队列的抽象类。队列可以用来存储和取出元素。

javaimport java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class MyQueue {
 private final BlockingQueue queue = new LinkedBlockingQueue<>();

 public void put(String element) throws InterruptedException {
 queue.put(element); // 放入队列 System.out.println("Added " + element);
 }

 public String take() throws InterruptedException {
 return queue.take(); // 取出队列 }

 public static void main(String[] args) {
 MyQueue queue = new MyQueue();

 try {
 queue.put("Hello");
 queue.put("World");

 System.out.println(queue.take());
 System.out.println(queue.take());
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }
}

**6. 并发集合**

Java23 并发包中的 `ConcurrentHashMap` 类是用于实现并发哈希表的抽象类。并发哈希表可以用来存储和取出元素。

javaimport java.util.concurrent.ConcurrentHashMap;

public class MyConcurrentMap {
 private final ConcurrentHashMap map = new ConcurrentHashMap<>();

 public void put(String key, String value) {
 map.put(key, value); // 放入并发哈希表 System.out.println("Added " + key + "=" + value);
 }

 public String get(String key) {
 return map.get(key); // 取出并发哈希表 }

 public static void main(String[] args) {
 MyConcurrentMap map = new MyConcurrentMap();

 map.put("Hello", "World");
 System.out.println(map.get("Hello"));
 }
}

**7. 并发计数器**

Java23 并发包中的 `AtomicInteger` 类是用于实现并发计数器的抽象类。并发计数器可以用来存储和取出整数值。

javaimport java.util.concurrent.atomic.AtomicInteger;

public class MyConcurrentCounter {
 private final AtomicInteger counter = new AtomicInteger(0);

 public void increment() {
 counter.incrementAndGet(); // 增加计数 System.out.println("Current count: " + counter.get());
 }

 public static void main(String[] args) {
 MyConcurrentCounter counter = new MyConcurrentCounter();

 for (int i =0; i < 10; i++) {
 counter.increment();
 }
 }
}

**8. 并发计时器**

Java23 并发包中的 `ScheduledExecutorService` 接口是用于实现并发计时器的抽象类。并发计时器可以用来执行定时任务。

javaimport java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MyConcurrentTimer {
 public static void main(String[] args) {
 ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); // 创建一个固定大小的线程池 executor.scheduleAtFixedRate(() -> System.out.println("Tick"),0,1, TimeUnit.SECONDS); // 每秒执行一次 }
}

**9. 并发信号**

Java23 并发包中的 `CyclicBarrier` 类是用于实现并发信号的抽象类。并发信号可以用来同步线程。

javaimport java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class MyConcurrentSignal {
 private final CyclicBarrier barrier = new CyclicBarrier(3); // 创建一个三元组 public void await() throws InterruptedException, BrokenBarrierException {
 barrier.await(); // 等待信号 }

 public static void main(String[] args) {
 MyConcurrentSignal signal = new MyConcurrentSignal();

 try {
 signal.await();
 System.out.println("All threads have arrived.");
 } catch (InterruptedException | BrokenBarrierException e) {
 Thread.currentThread().interrupt();
 }
 }
}

**10. 并发信号量**

Java23 并发包中的 `Semaphore` 类是用于实现并发信号量的抽象类。并发信号量可以用来控制线程数量。

javaimport java.util.concurrent.Semaphore;

public class MyConcurrentSemaphore {
 private final Semaphore semaphore = new Semaphore(3); // 创建一个三元组 public void acquire() throws InterruptedException {
 semaphore.acquire(); // 获取信号量 }

 public void release() {
 semaphore.release(); //释放信号量 }

 public static void main(String[] args) {
 MyConcurrentSemaphore semaphore = new MyConcurrentSemaphore();

 try {
 semaphore.acquire();
 System.out.println("Thread has acquired the semaphore.");
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }
}

以上是 Java23 并发包的主要类和接口。这些类和接口可以用来构建高性能、可伸缩的多线程应用程序。