常见的非阻塞队列

最新推荐文章于 2023-05-29 13:37:31 发布

dreams512

最新推荐文章于 2023-05-29 13:37:31 发布

阅读量2.8k

点赞数 1

CC 4.0 BY-SA版权

分类专栏：并发 java 文章标签： java 并发多线程

本文链接：https://blog.youkuaiyun.com/chuan_yu_chuan/article/details/53395976

java 同时被 2 个专栏收录

12 篇文章

订阅专栏

并发

4 篇文章

订阅专栏

本文介绍了Java中常见的非阻塞队列，包括ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、ConcurrentLinkedQueue、ConcurrentLinkedDeque、CopyOnWriteArrayList和CopyOnWriteArraySet。这些数据结构在并发环境下提供了高效的操作，例如ConcurrentHashMap采用弱一致性模型，ConcurrentSkipListMap保证排序，ConcurrentLinkedQueue支持并发队列操作，而CopyOnWriteArrayList和CopyOnWriteArraySet在写时复制策略下保证线程安全。同时，文章提及了HashTable和Vector在并发修改时的问题。

常见的非阻塞队列

1) ConcurrentHashMap
2) ConcurrentSkipListMap
3) ConcurrentSkipListSet
4) ConcurrentLinkedQueue
5) ConcurrentLinkedDeque
6) CopyOnWriteArrayList
7) CopyOnWriteArraySet

HashTable、Vector调用iterator()方法返回Iterator对象后，再调用remove()时会出现ConcurrentModificationException异常，也就是并不支持Iterator并发的删除。

ConcurrentHashMap是弱一致性模型
ConcurrentSkipListMap 并发程序中可以保证顺序

public class MyService {
    public ConcurrentSkipListMap map = new ConcurrentSkipListMap();
    public MyService(){
        UserInfo user1 = new UserInfo(1, "user1");
        UserInfo user2 = new UserInfo(2, "user2");
        UserInfo user3 = new UserInfo(3, "user3");
        UserInfo user4 = new UserInfo(4, "user4");
        UserInfo user5 = new UserInfo(5, "user5");
        map.put(user1, "value1");
        map.put(user4, "value4");
        map.put(user2, "value2");
        map.put(user5, "value5");
        map.put(user3, "value3");
    }
}

public class ThreadA extends Thread {
    private MyService myservice;
    public ThreadA(MyService myservice){
        this.myservice = myservice;
    }

    @Override
    public void run() {
        while(!myservice.map.isEmpty()){
            Map.Entry entry = myservice.map.pollFirstEntry();
            UserInfo userInfo = (UserInfo) entry.getKey();
            System.out.println("key = " + userInfo.getId() + entry.getValue());
        }
    }
}

ConcurrentSkipListSet 支持排序且不允许重复的元素
ConcurrentLinkedQueue 提供了并发环境的队列操作
方法poll当没有获得数据时返回null，如果有数据则移除表头，并将表头进行返回
方法element当没有数据时，出现NoSuchElementExcepiton异常，如果有数据则返回表头项
方法peek当没有数据时返回null，有数据则不移除表头，返回表头项
ConcurrentLinkedDeque

public class AddTask implements Runnable {
    private ConcurrentLinkedDeque<String> list;

    public AddTask(ConcurrentLinkedDeque<String> list){
        this.list = list;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for(int i=0;i<1000;i++){
            list.add(name+"--" + (i+1));
        }
    }
}

public class RemoveTask implements Runnable{

    private ConcurrentLinkedDeque list;

    public RemoveTask(ConcurrentLinkedDeque list){
        this.list = list;
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for(int i=0;i<500;i++){
            list.pollFirst();
            list.pollLast();
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {

        ConcurrentLinkedDeque<String> list = new ConcurrentLinkedDeque<>();
        Thread[] threads = new Thread[100];
        for(int i=0;i<threads.length;i++){
            AddTask task = new AddTask(list);
            threads[i] = new Thread(task);
            threads[i].start();
        }
        System.out.printf("Main %d AddTask have been launched\n", threads.length);

        for(int i=0;i<threads.length;i++){
            threads[i].join();
        }
        System.out.printf("Main size of threads %d\n", list.size());

        for(int i=0;i<threads.length;i++){
            RemoveTask removeTask = new RemoveTask(list);
            threads[i] = new Thread(removeTask);
            threads[i].start();
        }
        System.out.printf("Main %d RemoveTask have been launched\n", threads.length);

        for(int i=0;i<threads.length;i++){
            threads[i].join();
        }
        System.out.printf("Main size of threads %d\n", list.size());

    }
}