Java.多线程可能出的面试题(4)

目录

15.JUC 包下的工具类有哪些？

16.具体介绍ConcurrentHashMap

---

15.JUC 包下的工具类有哪些？

        1.线程池相关

         ThreadPoolExecutor：核心线程池实现类，可自定义线程池参数，如核心线程数、最大线程数等，灵活控制线程池行为。

import java.util.concurrent.*;public class ThreadPoolExecutorExample {public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(2,  // 核心线程数5,  // 最大线程数60, // 线程空闲时间TimeUnit.SECONDS,new LinkedBlockingQueue<>(10) // 任务队列);executor.execute(() -> System.out.println("Task is running."));executor.shutdown();}
}

   Executors：工具类，提供创建不同类型线程池的静态方法，不过部分方法可能有资源耗尽风险，实际生产推荐手动创建。

        2.并发集合

        ConcurrentHashMap：线程安全的哈希表，采用分段锁或 CAS 机制，在多线程环境下有高效的并发读写性能。

import java.util.concurrent.ConcurrentHashMap;public class ConcurrentHashMapExample {public static void main(String[] args) {ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();map.put("key", 1);System.out.println(map.get("key"));}
}

  CopyOnWriteArrayList：适用于读多写少场景的线程安全动态数组，写操作时创建新数组副本，保证读操作无需加锁。

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;public class CopyOnWriteArrayListExample {public static void main(String[] args) {List<String> list = new CopyOnWriteArrayList<>();list.add("element");System.out.println(list.get(0));}
}

        3.同步工具类

  CountDownLatch：允许线程等待其他线程完成操作，通过计数器控制，计数器为 0 时唤醒等待线程。

import java.util.concurrent.CountDownLatch;public class CountDownLatchExample {public static void main(String[] args) throws InterruptedException {CountDownLatch latch = new CountDownLatch(2);//计数器为2new Thread(() -> {System.out.println("Task 1 is running.");latch.countDown();}).start();new Thread(() -> {System.out.println("Task 2 is running.");latch.countDown();}).start();latch.await();System.out.println("All tasks are completed.");}
}

  只有两个线程都结束才会打印最后的 All tasks are completed

  CyclicBarrier：允许一组线程相互等待，直到所有线程都到达一个公共的屏障点，然后所有线程可以继续执行。与 CountDownLatch 不同的是，CyclicBarrier 可以重复使用。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;public class CyclicBarrierExample {public static void main(String[] args) {// 创建一个 CyclicBarrier 对象，指定需要等待的线程数量为 3// 并在所有线程到达屏障点后执行一个任务CyclicBarrier barrier = new CyclicBarrier(3, () -> {System.out.println("所有线程都已到达屏障点，开始执行屏障动作。");});// 创建并启动 3 个线程for (int i = 0; i < 3; i++) {new Thread(new Worker(barrier), "Thread-" + i).start();}}static class Worker implements Runnable {private final CyclicBarrier barrier;public Worker(CyclicBarrier barrier) {this.barrier = barrier;}@Overridepublic void run() {try {System.out.println(Thread.currentThread().getName() + " 正在执行任务。");// 模拟线程执行任务的耗时Thread.sleep((long) (Math.random() * 1000));System.out.println(Thread.currentThread().getName() + " 已到达屏障点，等待其他线程。");// 线程到达屏障点后进行等待barrier.await();System.out.println(Thread.currentThread().getName() + " 继续执行后续任务。");} catch (InterruptedException | BrokenBarrierException e) {e.printStackTrace();}}}
}

      await就是到达屏障点的信号

  Semaphore：控制同时访问资源的线程数量，利用许可证机制，线程访问资源前需获取许可证，完成后释放。

import java.util.concurrent.Semaphore;public class SemaphoreExample {public static void main(String[] args) {Semaphore semaphore = new Semaphore(2);for (int i = 0; i < 5; i++) {new Thread(() -> {try {semaphore.acquire();System.out.println(Thread.currentThread().getName() + " has acquired a permit.");Thread.sleep(1000);System.out.println(Thread.currentThread().getName() + " is releasing a permit.");semaphore.release();} catch (InterruptedException e) {e.printStackTrace();}}).start();}}
}

        4.锁相关

  ReentrantLock：可重入的互斥锁，功能类似 synchronized，但提供更灵活的锁机制，如可中断锁、公平锁。

  ReadWriteLock：读写锁接口，可以多线程进行读，但独占写，ReentrantReadWriteLock 是具体实现。

16.具体介绍ConcurrentHashMap

  oncurrentHashMap 是一个线程安全的哈希表，用于在多线程环境下存储和访问键值对。与传统的线程安全哈希表 Hashtable 不同，ConcurrentHashMap 采用了更细粒度的锁机制或无锁算法，从而在高并发场景下具有更好的性能。

        主要特性 ：

        (优)线程安全：在多线程环境下，多个线程可以同时对 ConcurrentHashMap 进行读写操作，而不需要额外的同步措施。

        (优)高效并发：通过更细粒度的锁机制或无锁算法，减少了线程之间的竞争，提高了并发性能。       

        (优)支持高并发读写：读操作通常不需要加锁，而写操作只会锁定正在操作的节点，不会影响其他节点的读写操作。

        (缺)弱一致性：ConcurrentHashMap 的迭代器是弱一致性的，意味着在迭代过程中，如果其他线程对 ConcurrentHashMap 进行了修改，迭代器可能不会反映这些修改，但不会抛出 ConcurrentModificationException 异常。

        常用方法：

  put(K key, V value)：将指定的键值对插入到 ConcurrentHashMap 中，如果键已经存在，则更新其值。

  get(Object key)：根据指定的键获取其对应的值，如果键不存在，则返回 null

  remove(Object key)：根据指定的键移除对应的键值对，并返回被移除的值，如果键不存在，则返回 null。

  size()：返回 ConcurrentHashMap 中键值对的数量。

  putIfAbsent ()：如果指定的键不存在，则插入该键值对，并返回 null；如果键已存在，则返回旧值。

  replace() ：尝试将指定键的旧值替换为新值，替换成功返回 true，否则返回 false。

        增删改查和一般的 HashMap 没啥区别，早知道不写那么多了

import java.util.concurrent.ConcurrentHashMap;public class ConcurrentHashMapUsageExample {public static void main(String[] args) {// 创建一个 ConcurrentHashMap 实例ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();// 使用 put 方法插入键值对System.out.println("使用 put 方法插入键值对...");concurrentHashMap.put("apple", 1);// 使用 get 方法获取指定键的值System.out.println("\n使用 get 方法获取键为 'banana' 的值...");Integer value = concurrentHashMap.get("banana");// 使用 remove 方法移除指定键的键值对System.out.println("\n使用 remove 方法移除键为 'cherry' 的键值对...");Integer removedValue = concurrentHashMap.remove("cherry");// 使用 size 方法获取键值对的数量System.out.println("\n使用 size 方法获取 ConcurrentHashMap 的大小...");int size = concurrentHashMap.size();// 使用 putIfAbsent 方法，如果键不存在则插入System.out.println("\n使用 putIfAbsent 方法插入键 'date'，如果不存在...");Integer putIfAbsentValue = concurrentHashMap.putIfAbsent("date", 4);// 使用 replace 方法替换指定键的值System.out.println("\n使用 replace 方法将键 'apple' 的值替换为 5...");boolean replaced = concurrentHashMap.replace("apple", 1, 5);}
}