Java集合线程安全

最新推荐文章于 2024-07-13 20:20:50 发布
最新推荐文章于 2024-07-13 20:20:50 发布
阅读量499 收藏 2
点赞数
分类专栏： JAVA 笔记 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45675449/article/details/116713683
版权
JAVA 同时被 2 个专栏收录
45 篇文章 1 订阅
订阅专栏
笔记
26 篇文章 1 订阅
订阅专栏

我们开启三个线程同时向集合中添加数据，每个线程向集合中添加1000个数据，正常情况下集合的长度应该是3000，但因为有些集合是非线程安全的，所以在添加过程中会出现问题，导致集合的实际长度不到3000


List集合

实现类：
非线程安全：ArrayList，LinkedList
线程安全：Vector

ArrayList

public class MyTest18 {
    static List<Integer> list = new ArrayList<Integer>();

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

//        输出十次列表长度
        for (int i = 0;i < 10;i++){

//            创建3个线程
            for (int j = 0;j < 3;j++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
//                        每个线程向list中添加1000个整数
                        for (int z = 0;z < 1000;z++){
                            list.add(z);
                        }
                    }
                }).start();
            }

//            等待所有线程执行完
            Thread.sleep(2000);
//            输出list的长度
            System.out.println(list.size());
//            清空列表
            list.clear();
        }

    }
}

在这里插入图片描述


LinkedList

public class MyTest18 {
    static List<Integer> list = new LinkedList<Integer>();

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

//        输出十次列表长度
        for (int i = 0;i < 10;i++){

//            创建3个线程
            for (int j = 0;j < 3;j++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
//                        每个线程向list中添加1000个整数
                        for (int z = 0;z < 1000;z++){
                            list.add(z);
                        }
                    }
                }).start();
            }

//            等待所有线程执行完
            Thread.sleep(2000);
//            输出list的长度
            System.out.println(list.size());
//            清空列表
            list.clear();
        }

    }
}

在这里插入图片描述


Vector

public class MyTest18 {
    static List<Integer> list = new Vector<Integer>();

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

//        输出十次列表长度
        for (int i = 0;i < 10;i++){

//            创建3个线程
            for (int j = 0;j < 3;j++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
//                        每个线程向list中添加1000个整数
                        for (int z = 0;z < 1000;z++){
                            list.add(z);
                        }
                    }
                }).start();
            }

//            等待所有线程执行完
            Thread.sleep(2000);
//            输出list的长度
            System.out.println(list.size());
//            清空列表
            list.clear();
        }

    }
}

因为Vector是线程安全的，所以列表的实际长度就是3000
在这里插入图片描述


Map集合

实现类：
非线程安全：HashMap，TreeMap
线程安全：Hashtable

HashMap

public class MyTest19 {

    static  Map<Integer,Integer> map = new HashMap<Integer, Integer>();

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

//        循环输出map长度10次
        for (int i = 0;i < 10;i++){
//            创建三个线程

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围 2000-2999
                        map.put(2*1000+i,2);
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围3000-3999
                        map.put(3*1000+i,2);
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围4000-4999
                        map.put(4*1000+i,2);
                    }
                }
            }).start();

//            等待线程执行完
            Thread.sleep(2000);
//            输出map长度
            System.out.println(map.size());
//            清空map
            map.clear();
        }

    }
}

在这里插入图片描述


TreeMap

public class MyTest19 {

    static  Map<Integer,Integer> map = new TreeMap<Integer, Integer>();

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

//        循环输出map长度10次
        for (int i = 0;i < 10;i++){
//            创建三个线程

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围 2000-2999
                        map.put(2*1000+i,2);
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围3000-3999
                        map.put(3*1000+i,2);
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围4000-4999
                        map.put(4*1000+i,2);
                    }
                }
            }).start();

//            等待线程执行完
            Thread.sleep(2000);
//            输出map长度
            System.out.println(map.size());
//            清空map
            map.clear();
        }

    }
}

在这里插入图片描述


Hashtable

public class MyTest19 {

    static  Map<Integer,Integer> map = new Hashtable<Integer, Integer>();

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

//        循环输出map长度10次
        for (int i = 0;i < 10;i++){
//            创建三个线程

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围 2000-2999
                        map.put(2*1000+i,2);
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围3000-3999
                        map.put(3*1000+i,2);
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 1000;i++){
//                        键范围4000-4999
                        map.put(4*1000+i,2);
                    }
                }
            }).start();

//            等待线程执行完
            Thread.sleep(2000);
//            输出map长度
            System.out.println(map.size());
//            清空map
            map.clear();
        }

    }
}

因为Hashtable是线程安全的，所以集合的实际长度是3000
在这里插入图片描述

SmallSweets
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程安全集合
03-17
Java的多种多线程安全集合的介绍和示例代码
Java 集合 线程安全
yangzl0123的专栏
12-29 9433
线程安全的集合包含2个问题   1.多线程并发修改一 个 集合 怎么办？   2.如果迭代的过程中 集合 被修改了怎么办？       a.一个线程在迭代，另一个线程在修改       b.在同一个线程内用同一个迭代器对象进行迭代、修改、迭代、修改. . .           共有有3种解决方案   1.用老的Vector/Hashtable类，上面2个问
Java中常用线程安全的集合
最新发布
努力分享一些干货内容，纯干货，没有一点水
07-13 834
锁定分段，在执行插入、删除或更新操作时，只有操作涉及的分段会被锁定，其他分段不受影响。在进行插入操作时，先根据键的哈希值确定应该操作哪个分段，然后锁定该分段并进行操作。它的基本原理是每次修改操作都会创建该列表的一个新副本，因此读操作不需要加锁，可以并发执行。每个分段独立加锁，细化了锁的粒度，同时允许多个线程同时操作不同的分段，从而提高并发性能。改进了这一点，不再使用固定的分段数量，而是根据当前的容量动态调整分段的数量，从而更好地适应不同的并发场景，提升了并发性能和灵活性。实例时，必须指定初始的分段数量。
Java中各种集合（字符串类）的线程安全性！！！
weixin_34266504的博客
10-31 531
Java中各种集合（字符串类）的线程安全性！！！   一、概念： 线程安全：就是当多线程访问时，采用了加锁的机制；即当一个线程访问该类的某个数据时，会对这个数据进行保护，其他线程不能对其访问，直到该线程读取完之后，其他线程才可以使用。防止出现数据不一致或者数据被污染的情况。 线程不安全：就是不提供数据访问时的数据保护，多个线程能够同时操作某个数据，从而出现数据不一致或者数据污染的情况。...
JAVA线程安全集合
WEBCODE
07-26 86
java.util.concurrent提供了队列和三列表的高校实现：concurrentLinkedQueue和concurrentHashMap. copyOnWriteArrayList和copyOnWriteArraySet 是线程安全的集合。
Java集合中线程安全的类
仅做个人笔记
02-19 5534
集合中线程安全的类都是jdk1.1中的出现的。在jdk1.2之后，就出现许多非线程安全的类。 下面是这些线程安全的同步的类： vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用 statck：堆栈类，先进后出 hashtable：就比hashmap多了个线程安全 enumeration：枚举，相当于迭代器 ...
详解java各种集合的线程安全
08-29
Java 集合的线程安全详解 Java 集合的线程安全是指在多线程环境中，集合操作的安全性。 Java 中有多种集合类，如 Vector、ArrayList、LinkedList、HashTable、HashMap、HashSet 等，这些集合类在多线程环境中的安全...
Java集合框架的线程安全.docx
05-10
Java 集合框架中的集合类也可以根据其线程安全等级进行分类，例如，非可变的集合类、线程安全的集合类、条件线程安全的集合类、线程兼容的集合类和线程不友好的集合类。了解这些集合类的线程安全等级可以帮助 Java ...
Java线程安全与非线程安全解析
08-29
Java线程安全与非线程安全解析是Java编程中一个非常重要的概念，对于Java开发者来说，理解线程安全和非线程安全的区别以及它们的实现方式是非常必要的。本文将详细介绍Java线程安全与非线程安全的概念、非线程安全...
Java集合多线程安全.docx
07-10
总的来说，Java集合的线程安全问题需要开发者在设计多线程程序时给予足够的关注。合理选择线程安全的集合类，或者使用同步机制对非线程安全的集合进行封装，是确保程序正确性的关键步骤。此外，Java并发库（如`...
JAVA集合-线程安全
Lyajpunov的博客
01-25 3237
一、其他的集合类 我们这里来介绍一点其他的集合类 1.1、Linkedhashmap Linkedhashmap在原来的基础上维护了一个双向链表，用来维护，插入的顺序。 public class LinkedHashMapTest { public static void main(String[] args){ Map<String,String> map = new LinkedHashMap<>(16); map.put("a","m"
java集合类的线程安全_Java集合中的线程安全问题
weixin_42133415的博客
02-24 1339
介绍JDK中提供了很多集合实现，本文不会介绍有哪些集合的接口以及实现类，而是介绍如何在多线程情况下使用这些集合。阅读更多…如果您还不太了解Java的整个集合体系的话，请查看《Java开发成长之路第一年》。如果您还想要了解线程的相关内容，请查看《Java多线程》。线程不安全java.util.HashMap、java.util.ArrayList、java.util.LinkedList、java....
java集合 线程安全
weixin_34146986的博客
01-17 110
1.快速失败(fail-fast)和安全失败(fail-safe)? 一：快速失败（fail—fast） 在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。 原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发...
Java线程安全集合
幻化成风
02-20 965
JUC并发编程 并发编程的本质：充分利用CPU资源。 1.准备环境 准备工作使用IDEA作为开发环境，新建一个Maven项目 1.添加一个包 <dependencies> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.1
Java 提供的线程安全集合
weixin_42679286的博客
07-16 863
最终一致性、写分离思想。用Volatile修饰，每次直接从内存地址中读取，读取时不加锁。写时用显式锁整个容器（防止其它写线程），然后拷贝一份副本，对副本操作，读线程访问原容器数据。内存开销大，实时数据一致性不高。适用于读远大于写操作且数据量不大的场景。
Java 线程安全的集合
热门推荐
不见其长，日有所长
12-01 1万+
1. 前言 在 Java 中我们使用最多的 List 就是 ArrayList 和 LinkedList，它们在单线程中可以说是”玩的不亦乐乎”，而在多线程并发操作时就不行了。Java 为我们提供了几种方式以适应多线程下的 List 操作场景。本文将介绍几个多线程中适用的 List，文章最后也会介绍线程安全的 Map、Set 以及 Queue 和 Deque 的几个实现类。 2. 使用 Collections.synchronizedList(List list) 因为 ArrayList 本身不是线程安全
java集合类的线程安全
壹升茉莉清的博客
08-10 687
集合类的线程安全为什么不是线程安全的出错原因二、如何保证线程安全List的线程安全CopyOnWriteArrayListSetMap 为什么不是线程安全的 我们都知道在java中，经常会用到三大集合类Set,List,Map。但是像ArrayList, HashMap,HashSet这些常用的结合类是线程不安全的。在高并发的场景下使用这些集合类会导致很多的问题，比如丢失数据，数据的不一致性等等，甚至导致异常，给生产环境带来严重的损失。 首先我们以List集合来举一个例子，来看看会导致的问题。 List&
java集合安全_java集合 线程安全
weixin_42361237的博客
02-12 458
1.快速失败(fail-fast)和安全失败(fail-safe)?一：快速失败(fail—fast)在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改(增加、删除、修改)，则会抛出Concurrent Modification Exception。原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会...
Java集合线程安全：从问题到解决方案
"Java集合在多线程环境下的安全性和解决方案" 在Java编程中，集合框架是处理数据的重要工具，但并非所有集合类都支持线程安全操作。线程安全意味着多个线程并发访问该对象时，其行为是正确和一致的。线程不安全的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值