多线程三 并发容器简单使用

已于 2023-03-05 22:54:30 修改
阅读量517 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程 队列 queue java
于 2020-04-06 17:26:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28911061/article/details/105343177
版权

目录

1.threadLocal

2.ArrayList、Vector、CopyOnWriteArrayList

 3.map相关并发容器

4.ConcurrentLinkedQueue

5.BlockingQueue提供的方法

5.1ArrayBlockingQueue

5.2LinkedBlockingQeque 

5.3DelayQueue

5.4LinkedTransferQueue 

5.5 PriorityBlockingQueue 

5.6 SynchronousQueue 

总结：

1.threadLocal

本地线程变量，在每个线程会独立开辟内存空间。

在高并发先谨慎使用；

注意：在使用后调用`

local.remove();

`方法移除变量

private static ThreadLocal local = new ThreadLocal();

public static void main(String[] args) {
    new Thread(()->{
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        local.set("A");
        System.out.println(Thread.currentThread().getName()+" "+local.get());
    },"线程 1").start();
    new Thread(()->{
        local.set("B");
        System.out.println(Thread.currentThread().getName()+" "+local.get());
    },"线程 2").start();
    System.out.println("main "+local.get());
// 移除线程变量
   local.remove();
}

2.ArrayList、Vector、CopyOnWriteArrayList

这里三个容器，ArrayList、vector和CopyOnwriteArrayList

从测试结果中可以看出：ArrayList不是线程安全，会进行很多重复的操作，致使在所有线程运行完后，大小达不到10000，而Vector是线程安全的，不会出现重复读，重复写的问题，而copyOnWriterArrayList呢，是读快，写慢，因为他写的时候要进行复制，大大拉低了效率；

 public static void main(String[] args) {
//        List<String> list1 = new ArrayList<>();// 耗时：12  大小：9754
//        Vector<String> list1 = new Vector<>(); // 耗时：10 大小：10000
        List<String> list1 = new CopyOnWriteArrayList<>(); // 写耗时：75 写大小：10000 读耗时：22
        Thread[] threads = new Thread[100];

        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            threads[i] =  new Thread(()->{
                for (int j = 0; j < 100; j++) {
                    int i1 = r.nextInt(10000);
                    list1.add("A"+i1);
                    ;
                }
            });
        }
        long time = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.start();
        }
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("大小 "+list1.size());
        System.out.println("耗时："+(end - time));

        Thread[] threads2 = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threads2[i] = new Thread(()->{
                for (int j = 0; j < 10000; j++) {
                    list1.get(j);
                }
            });
        }
        long time2 = System.currentTimeMillis();
        for (Thread thread : threads2) {
            thread.start();
        }
        for (Thread thread : threads2) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("耗时："+(System.currentTimeMillis() - time2));
    }

Collections提供了一个方法synchronizedList可以将非线程安全的容器转换为线程安全的容器，看它的实现就是在方法上加了一个synchronized关键字，但是使用iterator的时候就不行了，因为他调用的还是List本身的迭代器，没有做同步处理，所以在这种情况下要手动上锁；注意：我们常使用的增加for也是利用了迭代器。

List<String> list = new ArrayList<>();
List<String> strings = Collections.synchronizedList(list);

Synchronized 和Vecotr最主要的区别：

  1. vector扩容为原来的2倍长度，ArrayList扩容为原来的1.5倍

  2. synchronized有很好的扩展和兼容功能，它可以将所有的list的子类转成线程安全的类

  3. 使用synchronizedList的时候，进行遍历需要手动进行同步处理

  4. synchronizedlist可以指定锁定的对象

 3.map相关并发容器

public static void main(String[] args) {
//    Map<String, String> map = new ConcurrentHashMap<>(); // 302
//        Map<String, String> map = new ConcurrentSkipListMap<>(); // 358
//    Map<String, String> map = new Hashtable<>(); // 400

      Map<String, String> m = new HashMap<>();
      Map<String, String> map = Collections.synchronizedMap(m); // 465

        Random random = new Random();
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);
        long start = System.currentTimeMillis();
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                for(int j=0; j<10000;j++) {
                    map.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
//             map1.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
                }
                latch.countDown();
            });
        }
        Arrays.asList(threads).forEach(t->t.start());
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }

hashMap

hashTable

concurrentHashMap

key/value = null可以存储null键，nullvalue

key和value都不能存储

key和value都不能存储

初始容量

16

11

16

线程安全

否

是

是

效率

高

< concurrentHashMap

>hashTable

ConcurrentSkipListMap 和上面不同，他的实现方式不一样，且key是有序的，支持更高的并发，存取是是log(N)，和线程数无关，线程越多越能体现出优势。

4.ConcurrentLinkedQueue

模拟场景：1000张票，10个售票窗口

public class ThreadContainer2 {

    private static List<Integer> list = new ArrayList<Integer>();
    private Integer tickets = 100;

    public synchronized void sall(){
        if (tickets > 0) {
            list.add(tickets--);
            System.out.println(Thread.currentThread().getName()+" sall "+tickets);
        }
    }

    public Integer getTicket(){
        return tickets;
    }

    public static void main(String[] args) {
        ThreadContainer2 t = new ThreadContainer2();

        System.out.println("开始售票。。。");
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                while (true) {
                        try {
                            TimeUnit.SECONDS.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        t.sall();
                    }
            },"售票口 "+(i+1)).start();
        }
    }
}

使用ConcurrentLinkedQueue来实现看看：

private static Queue<Integer> list = new ConcurrentLinkedQueue<Integer>();

static{
    for (int i = 0; i < 1000; i++) {
        list.add(i);
    }
}

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            while (true) {
                // 这个方法是线程安全的
                Integer poll = list.poll();
                if (poll == null) {
                    break;
                }
                // 就算多个线程都同时来到这里，因为上一个代码是线程安全的，所以就算来到这，也是空
                System.out.println(Thread.currentThread().getName()+" ticket "+poll);
            }
        }," 售票口 "+i).start();
    }
}

代码简化了，没有之前的那种复杂

这个容器比较有用的方法：

ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue();

for (int i = 0; i < 10; i++) {
    queue.add("a"+i);
}
System.out.println("容器"+queue.size());
System.out.println("poll取值："+queue.poll());
System.out.println("poll 取值后的容器"+queue.size());
System.out.println("peek取值："+queue.peek());
System.out.println("peek取值后的容量："+queue.size());

这个容器多用于生产者和消费者问题

offer(e) // 队列可以放入，则返回true，不能返回false

poll()  // 取不到数据，返回null，取到的对象会被丢弃

peek()  //和poll一样，但是取出的对象不会被丢弃

add()  // 底层调用offer，不会抛出异常

5.BlockingQueue提供的方法

抛异常

特定值

阻塞

超时

插入

add(E e)

offer(E e)

put(E e)

offer(E e, long timeout, TimeUnit unit) 

移除

remove(Object o)

E poll()

take()

poll(long timeout, TimeUnit unit)

offer(E e);       // 队列可以放入，则返回true，不能返回false

offer(E e, long timeout, TimeUnit unit)     // 指定时间内，还不能放入就返回false

E poll()     // 取不到数据，返回null，取到的对象会被丢弃

poll(long timeout, TimeUnit unit)     // 指定时间内，能取到数据就取队头，没有则返回异常

E peek()    // 和poll一样，但是取出的对象不会被丢弃

5.1ArrayBlockingQueue

基于数组的有界队列，创建后无法改变容量

public static void main(String[] args) throws InterruptedException {
   BlockingQueue<String> strings = new ArrayBlockingQueue<>(10);
   for (int i = 0; i < 10; i++) {
      strings.put("a" + i);
   }
   strings.add("aaaa");
   strings.offer("aaaa",1, TimeUnit.SECONDS);
   System.out.println(strings);
}

5.2LinkedBlockingQeque 

无界，最大长度为Integer.MAX_VALUE

public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        Thread[] threads = new Thread[1];
        Thread[] threads2 = new Thread[10];

        for (int i = 0; i < 1; i++) {
            threads[i] = new Thread(()->{
//                while (true) {
                    for (int j = 0; j < 100; j++) {
                        try {
                            queue.put(j);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
//                }
            },"线程 "+i);
        }

        for (int i = 0; i < 10; i++) {
            threads2[i] = new Thread(()->{
                while (true) {
                    try {
                        System.out.println(Thread.currentThread().getName()+" 获取 "+queue.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        Arrays.asList(threads).forEach(a->a.start());
        Arrays.asList(threads2).forEach(a->a.start());
    }

5.3DelayQueue

队列中的元素需要实现Delayed接口，实现排序和延时的定义

public class ThreadContainer11 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<MyQ> queue = new DelayQueue<>();
        long start = System.currentTimeMillis();
        MyQ m1 = new MyQ(start+1000,"延迟1秒");
        MyQ m2 = new MyQ(start+2000,"延迟2秒");
        MyQ m3 = new MyQ(start+3000,"延迟3秒");
        MyQ m4 = new MyQ(start+4000,"延迟4秒");
        MyQ m5 = new MyQ(start+5000,"延迟5秒");
        queue.put(m1);
        queue.put(m2);
        queue.put(m3);
        queue.put(m4);
        queue.put(m5);

        for (int i = 0; i < 5; i++) {
            System.out.println(queue.take().getName());
        }
    }

    static class MyQ implements Delayed {
        long time ;
        String name;
        public MyQ(long time,String name){
            this.time = time;
            this.name = name;
        }
        // 定义剩余到期时间
        @Override
        public long getDelay(TimeUnit unit) {
            return time - System.currentTimeMillis();
        }

        // 定义排序规则
        @Override
        public int compareTo(Delayed o) {
            if (this.getDelay(TimeUnit.MICROSECONDS) < o.getDelay(TimeUnit.MICROSECONDS)) {
                return 1;
            }else if(this.getDelay(TimeUnit.MICROSECONDS) > o.getDelay(TimeUnit.MICROSECONDS)){
                return -1;
            }else {
                return 0;
            }
        }
        public String getName(){
            return name;
        }
    }
}

5.4LinkedTransferQueue 

比其他队列多一个transfer ;使用transfer 的方式例如有多个消费者，和一个生产者，当存在消费者的情况下，他会将对象给消费者，不会放到队列里，再让消费取，比较快

public static void main(String[] args) throws InterruptedException {
    LinkedTransferQueue<String> queue = new LinkedTransferQueue<>();

    Thread t1 = new Thread(()->{
        try {
            System.out.println("线程1 "+queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    Thread t2 = new Thread(()->{
        try {
            System.out.println("线程2 "+queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    t1.start();
    t2.start();
    
    queue.transfer("aaaaaa");
    System.out.println(queue.size());
}

5.5 PriorityBlockingQueue 

这个队列，会对放入的对象进行优先级排序，而优先级排序是有compareTo方法定义的，必须实现接口Comparable，但是他的排序只会将排序后的第一个放到队列第一个，其他仍是乱的

public class ThreadContainer8 implements Comparable {

    private Integer i;

    public ThreadContainer8(){}

    public ThreadContainer8(Integer i) {
        this.i = i;
    }

    @Override
    public int compareTo(Object o) {
        return i - ((ThreadContainer8) o).getI();
    }

    public Integer getI() {
        return i;
    }

    public static void main(String[] args) {
        PriorityBlockingQueue<ThreadContainer8> q = new PriorityBlockingQueue();
        Random r = new Random();
        Thread[] threads = new Thread[10];

      for (int i = 0; i < 10; i++) {
          threads[i] = new Thread(()->{
              for (int j = 0; j < 10; j++) {
                  q.put(new ThreadContainer8(r.nextInt(100)));
              }
          });
      }
        Arrays.asList(threads).forEach(t->t.start());
        Arrays.asList(threads).forEach(t->
                {
                    try {
                        t.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
        );
        q.forEach(e-> System.out.print(e.getI()+" "));
        System.out.println();
        System.out.println("s="+q.peek().getI());
    }
}

5.6 SynchronousQueue 

同步队列；容量为1，放入一个就要消费掉，不要用add

public static void main(String[] args) throws InterruptedException {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        // 报queue full异常
//        for (int i = 0; i < 5; i++) {
//            queue.add(i);
//        }
        System.out.println(queue.size());

        Thread t1 = new Thread(()->{
            try {
                System.out.println("线程1 "+queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(()->{
            try {
                System.out.println("线程2 "+queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        for (int i = 0; i < 2; i++) {
            queue.put(i);
        }
    }

总结：

名称

类名

说明

List相关并发容器

CopyOnWriteArrayList

读快写慢；写前复制，写完替换

Map/Set相关并发容器

ConcurrentHashMap

key和value都不能存储null，初始容量16

ConcurrentSkipListMap

key和value都不能存储null；key有序；它的存取时间log(N)

队列相关容器

ConcurrentLinkedQeque

FIFO（先入先出）；cas实现

ConcurrentLinkedDueue

与ConcurrentLinkedQeque不同的是支持双向操作

ArrayBlockingQueue

有界队列，固定容量，不支持空元素

DelayQueue

提供过期时间功能；队列头是最接近过期的元素，没有过期元素则会取出null

LinkedBlockingQeque

无界队列，最大是Integer.MAX_VALUE；添加删除不是互斥的

LinkedBlockingDueue

双向阻塞队列

LinkedTransferQueue

比其他队列多transfer方法，这个方法是会将元素给一个正在等待的消费者，不会放入队列，没有消费者则等待

PriorityBlockingQueue

放入对象必须实现Comparable接口，按compareTo实现方法，将优先级高的放在第一个，其他对象无序

SynchronousQueue

容量为1，即时消费，提供了put的阻塞方法，底层使用transfer 

线程池
cLover_xiaolei的博客
03-12 269
下面将从线程的设计思路及线程池的使用进行说明。线程池管理主体设计思路是：1、封装线程管理对象 MyThread，用于线程创建、线程开启、线程睡眠、任务绑定等操作。2、封装空闲线程栈管理对象IdleThreadContainer，用于空闲线程栈的维护管理等操作。空闲的线程放于此栈中。3、封装忙碌线程队列管理对象BusyThreadContainer，用于忙碌线程队列的维护及管理等操作。忙碌的线程放于...
Java多线程编程中的两种常用并发容器讲解
09-03
Java并发编程中，ConcurrentHashMap和CopyOnWriteArrayList是两种常用的并发容器，它们设计的目标是在多线程环境下提供高效且安全的数据访问。这里主要聚焦于ConcurrentHashMap的讲解。 **ConcurrentHashMap概述** ...
线程池可用的各种高并发容器
Ives_WangShen的博客
10-08 438
高并发容器总结
线程安全及线程并发容器
m0_59091195的博客
08-17 79
线程安全问题
java获取随机数(java获取随机数整数)
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
12-10 7171
在Java中产生随机数有什么方法？ 最后的结果就是生成1到100之间的随机偶数。其实，如果要范围随机奇数的话，至需要对上面的语句进行稍微的修改即可。Java: 改变你我的世界 假设现在用户想生成一个任意范围内的奇数或者偶数，能够实现吗?假设现在用户想实现一个m到n之间的任意偶数(其中m 可见虽然random方...
Java的 Container
weixin_63490470的博客
12-28 1614
在Java中，Container是一个抽象类，位于java.awt包中，它是轻量级组件（如按钮、文本框和标签）的抽象超类，也可以包含其他容器。Container继承自Component类，因此它本身也可以作为组件添加到其他容器中。ContainerContainer可以添加、移除或枚举它包含的组件。：每个Container都有一个，负责自动确定其子组件的大小和位置。：它负责将事件从顶层窗口传递到适当的子组件。下面是Container：将指定的组件添加到此容器的末尾。：从此容器中移除指定的组件。
人工智能-项目实践-多线程-Java多线程高并发实例.zip
最新发布
01-04
例如，可能包含使用线程池处理大量任务、使用并发容器实现数据共享、使用并发工具类进行线程同步，以及如何通过锁和原子类来保证数据一致性等。通过分析和运行这些代码，你将能够更深入地理解Java多线程在高并发场景...
多线程与高并发-电子.pdf
05-03
并发容器，如ConcurrentHashMap，是专为多线程环境设计的线程安全容器。它们能够提供比传统同步容器如Hashtable更好的性能。线程池是一种资源池化技术，用于管理线程的生命周期，减少线程创建和销毁的开销，同时合理...
Java多线程与并发库视频资源网盘链接
04-11
4. **并发库（java.util.concurrent）**：Java并发库提供了强大的工具，如Executor框架、Future、Callable接口以及并发容器（如ConcurrentHashMap、CopyOnWriteArrayList等）。这些工具能够帮助开发者更高效地管理...
24 经典并发容器，多线程面试必备。—深入解析ConcurrentHashMap.pdf
06-15
【并发容器的线程安全性】与`HashMap`不同，`ConcurrentHashMap`通过采用非阻塞算法（如CAS操作）和分段锁机制来保证并发性能，避免了整个表的锁定，提高了在多线程环境下的并发性和性能。 【存储结构】`...
48、线程
戏拈秃笔的博客
11-30 580
线程
Prometheus cadvisor组件监控指标概述
weixin_44545140的博客
07-04 2154
Prometheus cadvisor监控指标分类统揽
Java中Random类的nextInt()方法详解
热门推荐
Jack小站
03-29 2万+
请先看看Random类中nextInt()方法的内部实现： public int nextInt(int n) { if (n <= 0) throw new IllegalArgumentException("n must be positive"); if ((n & -n) == n) // i.e., n is a power o
nextInt（）是无范围的随机数 但是nextInt（n）是从0到n的随机数
a916121151的博客
03-14 2544
nextInt（）是无范围的随机数 但是nextInt（n）是从0到n的随机数
多线程处理容器ExecutorCompletionService使用
肖邦
12-04 2万+
一、多线程的好处： 接口调用，往往离不开多线程，可以减少响应时间 二、场景： 1、业务A有1W个条形码需要调用第三方（商品服务）获取商品信息接口 2、第三方（商品服务）获取商品信息接口， 单次只允许传入10个条形码来查询 三、代码： import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springfr...
JAVA技巧---多线程容器式处理数据——主线程开启多线程处理数据并等待
lanhezhong的博客
11-06 1001
假如你无意中有幸看到这篇文章，那么恭喜你，你将注定与别人不一样。         我将介绍如何用一段简单的代码，实现指定数量的多线程共同处理一件可分割的事情，并进行线程等待。或者说实现一个容器，这个容器里有8个线程，这8个线程共同处理一份较大的数据，并且主线程会等待所有数据执行完再往下执行。       我估计上面的话你应该看不明白，只怪我没学好语文，语文老师要是知道我语文这么烂，不知道还认不...
【prometheus】-06 Kubernetes云原生监控之cAdvisor容器资源监控
god_86的专栏
09-01 1112
【prometheus】-05 Kubernetes云原生监控之节点性能监控2021-08-30 【prometheus】-04 轻松搞定Prometheus Eureka服务发现2021...
Java线程入门（3）- 多线程常用方法，悟到了吗？
应钟二十六的博客
01-04 498
目录常用API 总结概览静态 -Yield 方法实例方法-join中断线程获取中断标志位interrupt 和 isInterrupted(）线程状态 Thread.State线程的优先级守护线程 常用API 总结概览 方法 描述 静态方法 作用在当前代码所在的线程 static void sleep（long millis ） 当前线程休眠 给定的时间，时间单位是毫秒 static Thread currentThred 获取代码行所在的当前线程 static void
java多线程-慎重使用volatile关键字
我爱大海V5的专栏
12-02 836
Java语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量。这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile 变量的同步性较差（但有时它更简单并且开销更低），而且其使用也更容易出错。 public volatile boolean exit = false; 在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步
Java多线程编程与并发容器详解
了解并熟练使用这些并发工具是成为多线程编程专家的关键。在实际应用中，根据需求选择合适的并发工具，可以大大提高程序的并发性能和稳定性。通过深入学习这些内容，开发者可以更好地应对高并发场景，设计出更加健壮...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值