多线程 - 常用多线程集合

ゞ浴缸里的玫瑰 2024-03-22 16:49 90阅读 0赞

## CopyOnWriteArray系列 ##

### CopyOnWriteArrayList ###

CopyOnWriteArrayList 是 Java 中的一个并发集合，它是 ArrayList 的线程安全版本。 和 ArrayList 不同的是，CopyOnWriteArrayList 采用了一种写时复制的策略，在写入操作时，它会先复制一个原有的数组，并进行修改操作，然后再将修改后的数组赋值给成员变量。

import java.util.concurrent.CopyOnWriteArrayList;
    
    /**
     * CopyOnWriteArrayList 是 Java 中的一个并发集合，它是 ArrayList 的线程安全版本。
     * 和 ArrayList 不同的是，CopyOnWriteArrayList 采用了一种写时复制的策略，在写入操作时，它会先复制一个原有的数组，并进行修改操作，
     * 然后再将修改后的数组赋值给成员变量。
     *
     * 这样可以保证读操作不受影响，而且不需要进行锁的操作。
     *
     *
     * 使用 CopyOnWriteArrayList 和使用普通的 ArrayList 非常相似，只不过 CopyOnWriteArrayList 支持并发读写，
     * 而且当集合进行修改时，不会出现并发问题。
     *
     * 如果在并发环境下需要使用集合，那么 CopyOnWriteArrayList 可以作为一个很好的选择。
     * 需要注意的是，由于写入操作需要复制原有的数组，所以 CopyOnWriteArrayList 的写入效率较低，适合读操作频繁，写操作较少的场景。
     */
    public class MyCopyOnWriteArrayListExample {
        
        public static void main(String[] args) {
        
            // 创建 CopyOnWriteArrayList 对象
            CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
            
            // 将数据放入 CopyOnWriteArrayList 中
            list.add("Java");
            list.add("Python");
            list.add("Golang");
            
            // 获取 CopyOnWriteArrayList 中的元素
            System.out.println("Value of first element: " + list.get(0));
            
            // 删除 CopyOnWriteArrayList 中的元素
            list.remove("Python");
            System.out.println("Value of first element after remove: " + list.get(0));
            
            // 判断 CopyOnWriteArrayList 是否包含指定元素
            System.out.println("Is list contains Python: " + list.contains("Python"));
            
            // 获取 CopyOnWriteArrayList 的大小
            System.out.println("Size of list: " + list.size());
        }
    }

### CopyOnWriteArraySet ###

CopyOnWriteArraySet 是 Java 中的一种并发集合实现，它是 CopyOnWriteArrayList 的升级版，使用了和 CopyOnWriteArrayList 相同的原理，只不过是对 Set 进行了支持。

package com.lfsun.highconcurrency000.aggregate;
    
    import java.util.Iterator;
    import java.util.concurrent.CopyOnWriteArraySet;
    
    /**
     * CopyOnWriteArraySet 是 Java 中的一种并发集合实现，它是 CopyOnWriteArrayList 的升级版，
     * 使用了和 CopyOnWriteArrayList 相同的原理，只不过是对 Set 进行了支持。
     *
     * 和 ConcurrentSkipListSet 不同，CopyOnWriteArraySet 不是有序的集合。
     * 它的元素无序，不支持按照自然顺序排序（或者按照提供的 Comparator 排序）。
     *
     * CopyOnWriteArraySet 也是线程安全的，支持并发读写，但是写操作比较耗时。
     * 当向 CopyOnWriteArraySet 中添加或者删除元素时，需要先将底层数组进行复制，再进行修改操作。因此，CopyOnWriteArraySet 适合读多写少的场景。
     *
     * 使用 CopyOnWriteArraySet 和使用普通的 Set 很相似，只不过 CopyOnWriteArraySet 支持并发读写，而且当对集合进行修改时，需要进行复制操作，
     * 因此对于写操作较多的场景，CopyOnWriteArraySet 的性能会比较低下
     */
    public class MyCopyOnWriteArraySetExample {
        
        public static void main(String[] args) {
        
            // 创建 CopyOnWriteArraySet 对象
            CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<>();
            
            // 将数据放入 CopyOnWriteArraySet 中
            set.add(1);
            set.add(3);
            set.add(2);
            
            // 获取 CopyOnWriteArraySet 中的元素
            System.out.println("Value of 1: " + set.contains(1));
            System.out.println("Value of 2: " + set.contains(2));
            System.out.println("Value of 3: " + set.contains(3));
            
            // 移除 CopyOnWriteArraySet 中的元素
            set.remove(2);
            System.out.println("Value of 2 after remove: " + set.contains(2));  // 输出 false
            
            // 迭代 CopyOnWriteArraySet 中的元素
            Iterator<Integer> iterator = set.iterator();
            while (iterator.hasNext()) {
        
                Integer value = iterator.next();
                System.out.println("Value: " + value);
            }
        }
    }

## Concurrent系列 ##

### ConcurrentSkipListSet ###

ConcurrentSkipListSet 是 Java 中的一种并发有序集合实现，它基于跳表（Skip List）算法，能够保证元素按照自然顺序排序（或者按照提供的 Comparator 排序）。

import java.util.concurrent.ConcurrentSkipListSet;
    
    /**
     * ConcurrentSkipListSet 是 Java 中的一种并发有序集合实现，它基于跳表（Skip List）算法，
     * 能够保证元素按照自然顺序排序（或者按照提供的 Comparator 排序）。
     *
     * 和 ConcurrentSkipListMap 一样，ConcurrentSkipListSet 也是线程安全的，支持并发读写。
     * 除此之外，ConcurrentSkipListSet 还提供了一些基于集合的操作，例如：添加、删除、获取、迭代等等。
     *
     *
     * 使用 ConcurrentSkipListSet 和使用普通的 Set 很相似，
     * 只不过 ConcurrentSkipListSet 能够保证元素按照自然顺序排序（或者按照提供的 Comparator 排序），并且支持并发读写。
     * 需要注意的是，由于 ConcurrentSkipListSet 中的元素是有序的，因此插入和删除的操作会比较耗时。
     */
    public class MyConcurrentSkipListSetExample {
        
        public static void main(String[] args) {
        
            // 创建 ConcurrentSkipListSet 对象
            ConcurrentSkipListSet<Integer> set = new ConcurrentSkipListSet<>();
            
            // 将数据放入 ConcurrentSkipListSet 中
            set.add(1);
            set.add(3);
            set.add(2);
            
            // 获取 ConcurrentSkipListSet 中的元素
            System.out.println("Value of 1: " + set.contains(1));
            System.out.println("Value of 2: " + set.contains(2));
            System.out.println("Value of 3: " + set.contains(3));
            
            // 移除 ConcurrentSkipListSet 中的元素
            set.remove(2);
            System.out.println("Value of 2 after remove: " + set.contains(2));  // 输出 false
            
            // 迭代 ConcurrentSkipListSet 中的元素
            for (Integer value : set) {
        
                System.out.println("Value: " + value);
            }
        }
    }

### ConcurrentSkipListMap ###

ConcurrentSkipListMap 是 Java 中的一种并发有序映射表（Map）实现，基于跳表（Skip List）算法。它具有与 ConcurrentHashMap 相似的并发性质，并且能够保证元素按照自然顺序排序（或者按照提供的 Comparator 排序）。

import java.util.Map;
    import java.util.concurrent.ConcurrentSkipListMap;
    
    /**
     *
     * ConcurrentSkipListMap 是 Java 中的一种并发有序映射表（Map）实现，基于跳表（Skip List）算法。
     * 它具有与 ConcurrentHashMap 相似的并发性质，并且能够保证元素按照自然顺序排序（或者按照提供的 Comparator 排序）。
     *
     * ConcurrentSkipListMap 中的元素是按照键进行排序的，因此如果想要按照值排序，则需要将值作为键来进行排序。
     * 另外，需要注意的是，ConcurrentSkipListMap 中的元素是有序的，因此插入和删除的操作会比较耗时。
     *
     *
     * 使用 ConcurrentSkipListMap 和使用普通的 Map 很相似，
     * 只不过 ConcurrentSkipListMap 能够保证元素按照自然顺序排序（或者按照提供的 Comparator 排序），并且支持并发读写。
     * 需要注意的是，由于 ConcurrentSkipListMap 中的元素是有序的，因此插入和删除的操作会比较耗时。
     */
    public class MyConcurrentSkipListMapExample {
        
        public static void main(String[] args) {
        
            // 创建 ConcurrentSkipListMap 对象
            ConcurrentSkipListMap<Integer, String> map = new ConcurrentSkipListMap<>();
            
            // 将数据放入 ConcurrentSkipListMap 中
            map.put(1, "A");
            map.put(3, "C");
            map.put(2, "B");
            
            // 获取 ConcurrentSkipListMap 中的元素
            System.out.println("Value of 1: " + map.get(1));
            System.out.println("Value of 2: " + map.get(2));
            System.out.println("Value of 3: " + map.get(3));
            
            // 移除 ConcurrentSkipListMap 中的元素
            map.remove(2);
            System.out.println("Value of 2 after remove: " + map.get(2));  // 输出 null
            
            // 迭代 ConcurrentSkipListMap 中的元素
            for (Map.Entry<Integer, String> entry : map.entrySet()) {
        
                System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
            }
        }
    }

### ConcurrentLinkedQueue ###

ConcurrentLinkedQueue 是 Java 中的一个并发队列实现，它是一个基于链表实现的无界队列，采用先进先出（FIFO）的原则对元素进行排序。

import java.util.concurrent.ConcurrentLinkedQueue;
    
    /**
     * ConcurrentLinkedQueue 是 Java 中的一个并发队列实现，它是一个基于链表实现的无界队列，采用先进先出（FIFO）的原则对元素进行排序。
     *
     * 和 LinkedList 不同，ConcurrentLinkedQueue 支持并发读写，可以被多个线程同时操作而不会出现问题。
     * 它的内部实现采用了一些锁分离和无锁算法的技术，使得在多线程情况下效率较高。
     *
     * 使用 ConcurrentLinkedQueue 和使用普通的队列很相似，只不过 ConcurrentLinkedQueue 支持并发读写，
     * 而且当队列进行修改时，不会出现并发问题。如果在并发环境下需要使用队列，那么 ConcurrentLinkedQueue 可以作为一个很好的选择。
     */
    public class MyConcurrentLinkedQueueExample {
        
        public static void main(String[] args) {
        
            // 创建 ConcurrentLinkedQueue 对象
            ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
            
            // 将数据放入 ConcurrentLinkedQueue 中
            queue.offer(1);
            queue.offer(2);
            queue.offer(3);
            
            // 获取 ConcurrentLinkedQueue 中的元素
            System.out.println("Value of first element: " + queue.peek());
            
            // 删除 ConcurrentLinkedQueue 中的元素
            queue.poll();
            System.out.println("Value of first element after poll: " + queue.peek());
            
            // 判断 ConcurrentLinkedQueue 是否包含指定元素
            System.out.println("Is queue contains 2: " + queue.contains(2));
            
            // 获取 ConcurrentLinkedQueue 的大小
            System.out.println("Size of queue: " + queue.size());
        }
    }

### ConcurrentLinkedDeque ###

ConcurrentLinkedDeque 是 Java 中的一个并发双端队列，它是 Deque 接口的一个线程安全实现。 和 ConcurrentLinkedQueue 类似，ConcurrentLinkedDeque 也是一个基于链表实现的队列，但是它支持从队列两端进行操作，并且提供了更加丰富的方法，比如可以从头部或尾部进行元素的获取、添加和删除。

import java.util.concurrent.ConcurrentLinkedDeque;
    
    /**
     * ConcurrentLinkedDeque 是 Java 中的一个并发双端队列，它是 Deque 接口的一个线程安全实现。
     * 和 ConcurrentLinkedQueue 类似，ConcurrentLinkedDeque 也是一个基于链表实现的队列，但是它支持从队列两端进行操作，并且提供了更加丰富的方法
     * ，比如可以从头部或尾部进行元素的获取、添加和删除。
     *
     * ConcurrentLinkedDeque 的特点是非常适合在高并发的场景下使用，因为它提供了一种无锁的并发访问机制，能够保证线程安全的同时，提高了并发效率。
     *
     * 使用 ConcurrentLinkedDeque 和使用普通的 Deque 接口非常相似，
     * 只不过 ConcurrentLinkedDeque 支持并发读写，并且提供了更多的方法。
     *
     * 如果需要在高并发的场景下使用队列，并且需要支持从队列两端进行操作，那么 ConcurrentLinkedDeque 是一个很好的选择。
     */
    public class MyConcurrentLinkedDequeExample {
        
        public static void main(String[] args) {
        
            // 创建 ConcurrentLinkedDeque 对象
            ConcurrentLinkedDeque<String> deque = new ConcurrentLinkedDeque<>();
            
            // 将元素添加到队列头部
            deque.addFirst("Java");
            deque.addFirst("Python");
            deque.addFirst("Golang");
            
            // 获取队列头部元素，并从队列中删除
            String first = deque.pollFirst();
            System.out.println("First element: " + first);
            
            // 将元素添加到队列尾部
            deque.addLast("PHP");
            
            // 获取队列尾部元素，并从队列中删除
            String last = deque.pollLast();
            System.out.println("Last element: " + last);
            
            // 获取队列大小
            System.out.println("Size of deque: " + deque.size());
        }
    }

### ConcurrentHashMap ###

import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * 使用 ConcurrentHashMap 和使用普通的 HashMap 很相似，只不过 ConcurrentHashMap 支持并发读写，可以在多线程的环境下安全地使用。
     * 需要注意的是，虽然 ConcurrentHashMap 支持并发读写，但在一些特殊情况下，可能会出现一些意外的情况，因此在使用时需要仔细考虑线程安全问题。
     */
    public class MyConcurrentHashMapExample {
        
        public static void main(String[] args) {
        
            // 创建 ConcurrentHashMap 对象
            ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
    
            // 将数据放入 ConcurrentHashMap 中
            map.put("A", 1);
            map.put("B", 2);
            map.put("C", 3);
    
            // 获取 ConcurrentHashMap 中的元素
            System.out.println("Value of A: " + map.get("A"));
            System.out.println("Value of B: " + map.get("B"));
            System.out.println("Value of C: " + map.get("C"));
    
            // 移除 ConcurrentHashMap 中的元素
            map.remove("B");
            System.out.println("Value of B after remove: " + map.get("B"));  // 输出 null
    
            // 替换 ConcurrentHashMap 中的元素
            map.replace("C", 4);
            System.out.println("Value of C after replace: " + map.get("C"));  // 输出 4
    
            // 迭代 ConcurrentHashMap 中的元素
            for (ConcurrentHashMap.Entry<String, Integer> entry : map.entrySet()) {
        
                System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
            }
        }
    }