同步容器类--Vector--并不是绝对的线程安全

最新推荐文章于 2022-02-06 11:29:56 发布
最新推荐文章于 2022-02-06 11:29:56 发布
阅读量581 收藏
点赞数
分类专栏： java集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoming19870124/article/details/81157560
版权

（一）同步容器类

1.  同步容器的分类：

       a.  早期JDK的同步容器类包括Vector和Hashtable；

       b.  JDK1.2种添加的一些功能相似的类，这些同步的封装器类是由Collections.synchronizedXxx等工厂方法创建。这些类实现线程安全的方式是：将它们的状态封装起来，并对每个公有方法都进行同步，使得每次只有一个线程能访问容器的状态。

2.  同步容器的问题--单个公有方法都是同步的（具有原子性），但有些复合操作不具有原子性，使用时应小心

       在Vector中，线程安全指的是：增删改查方法都是原子性的，在同一时刻，只能由一个线程访问，而复合操作是非原子性的，当多个线程交叉访问不同的同步方法时，会出现线程非安全的情况；

       如下代码演示了会出问题的复合操作：向vector放入5个不重复的元素，放入元素前先判断集合中是否已经存在--使用contains方法，如果不存在则加入--使用add方法，其中contains方法和add方法都是线程同步的，并给出了在JDK中的源码：

  Vector中的contains源码：

 public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
 }
 public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
 }

Vector中的add源码：

 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

 

1. package test;
2. import java.util.Vector;
3. import java.util.concurrent.CyclicBarrier;
4. public class MyVector2 {
5.     final static  Vector<String> vector = new Vector<String>();
6. 	final static CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
7.     public static void main(String[] args) throws InterruptedException {
8.     	testThread();//启动两个线程同时往容器中添加元素
9.     	Thread.sleep(100);//暂停100毫秒，等待两个线程执行完
10.     	vector.sort(null);
11. 		for(int j = 0; j < vector.size(); j++){
12.     		System.out.println("vector.size() = " + vector.size() + " , " + vector.get(j));
13.     	}
14. 		System.out.println(Thread.currentThread().getName() + "，執行完毕。");
15.     }
16.     public static void testThread(){
17.     	new Thread(new Runnable(){
18.     		public void run(){
19.     			addNumber();
20.     		}
21.     	},"t1").start();;
22.     	new Thread(new Runnable(){
23.     		public void run(){
24.     			addNumber();
25.     		}
26.     	},"t2").start();
27.     }
28.     
29.     public static void addNumber()
30.     {
31.     	System.out.println(Thread.currentThread().getName() + "，到达");
32.     	try {
33. 			cyclicBarrier.await();//使用栅栏，当两个线程都到达后，一起往容器中添加元素
34. 		} catch (Exception e) {
35. 			e.printStackTrace();
36. 		} 
37.     	System.out.println(Thread.currentThread().getName() + "，开始执行");
38.     	for(int i = 0; i < 5; i++){
39.     		String str = i + "";
40.     			if(!vector.contains(str))
41.         		{
42.         			System.out.println(Thread.currentThread().getName() + "，str = " + str);
43.         			vector.add(str);
44.         		}
45.     	}
46.     }
47. }

其中一次地运行结果如下：

t1，到达
t2，到达
t1，开始执行
t2，开始执行
t1，str = 0
t2，str = 0
t1，str = 1
t1，str = 2
t1，str = 3
t1，str = 4
t2，str = 3
vector.size() = 7 , 0
vector.size() = 7 , 0
vector.size() = 7 , 1
vector.size() = 7 , 2
vector.size() = 7 , 3
vector.size() = 7 , 3
vector.size() = 7 , 4
main，執行完毕。

根据代码的输出结果，我做了如下分析：

        a. 在代码中使用了栅栏，当两个线程t1和t2都到达第33行时，这两个线程开始执行第38行的for循环；

        b. 第一次循环：由于第40行的方法contains是同步方法，在同一时刻只能有一个线程在执行，根据输出得知，t1先获取到的contains方法的执行权，t2被阻塞；当线程t1执行完第40行代码，而没执行第43行代码时，中间会有一个非常短的时间，在这个非常短的时间会发生如下事情：此时容器中是空的，线程t1执行contains方法后返回true，线程t1释放锁，线程t2获取锁，线程t2获取锁之后，接着执行contains方法，由于此时容器中没有元素0，所以也会返回true；线程t2释放锁之后，线程t1要开始执行add方法，线程t1在执行add方法之前，必须先获取锁，然后才能执行add方法，线程t1在执行完add方法后释放锁，此时容器中就有了个元素0；线程t2这时候开始执行add方法，由于在执行contains方法时，元素0还不在容器中，所以线程t2也会把元素0放入到容器中，此时，容器中就有了两个0元素；

      c. 第二、三次循环与第五次循环情况一样：由于线程t1执行的较快，当线程t1执行完add方法后（元素1、2、4已经添加到容器中），线程t2才开始执行contains方法，由于元素1、2、4已经在容器中了，所以线程t2不能将元素1和元素2添加到容器中了；

        d. 第四次循环与第一次循环的情况一样，所以容器中含有两个元素3：

    若向容器中，添加5个不同的元素，则需要将这个复合操作加锁，其改动后的代码如下：

public static void addNumber()
{
    	System.out.println(Thread.currentThread().getName() + "，到达");
    	try {
			cyclicBarrier.await();//使用栅栏，当两个线程都到达后，一起往容器中添加元素
		} catch (Exception e) {
			e.printStackTrace();
		} 
    	System.out.println(Thread.currentThread().getName() + "，开始执行");
//    	synchronized(vector){第一种加锁地点
    		for(int i = 0; i < 5; i++){
        		String str = i + "";
//        		synchronized(vector){第二种加锁地点
        			if(!vector.contains(str))
            		{
            			System.out.println(Thread.currentThread().getName() + "，str = " + str);
            			vector.add(str);
            		}
//        		}
        	}
//    	}
    }

若是对addNumber整个方法加锁，就会出现死锁，其错误代码如下：

1. package test;
2. import java.util.Vector;
3. import java.util.concurrent.CyclicBarrier;
4. public class MyVector2 {
5.     final static  Vector<String> vector = new Vector<String>();
6. 	final static CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
7.     public static void main(String[] args) throws InterruptedException {
8.     	testThread();//启动两个线程同时往容器中添加元素
9.     	Thread.sleep(100);//暂停100毫秒，等待两个线程执行完
10.     	vector.sort(null);
11. 		for(int j = 0; j < vector.size(); j++){
12.     		System.out.println("vector.size() = " + vector.size() + " , " + vector.get(j));
13.     	}
14. 		System.out.println(Thread.currentThread().getName() + "，執行完毕。");
15.     }
16.     public static void testThread(){
17.     	new Thread(new Runnable(){
18.     		public void run(){
19.     			addNumber();
20.     		}
21.     	},"t1").start();;
22.     	new Thread(new Runnable(){
23.     		public void run(){
24.     			addNumber();
25.     		}
26.     	},"t2").start();
27.     }
28.     
29.     public static synchronized void addNumber()
30.     {
31.     	System.out.println(Thread.currentThread().getName() + "，到达");
32.     	try {
33. 			cyclicBarrier.await();//使用栅栏，当两个线程都到达后，一起往容器中添加元素
34. 		} catch (Exception e) {
35. 			e.printStackTrace();
36. 		} 
37.     	System.out.println(Thread.currentThread().getName() + "，开始执行");
38.     	for(int i = 0; i < 5; i++){
39.     		String str = i + "";
40.     			if(!vector.contains(str))
41.         		{
42.         			System.out.println(Thread.currentThread().getName() + "，str = " + str);
43.         			vector.add(str);
44.         		}
45.     	}
46.     }
47. }

       出现死锁的原因是：当线程t1开始执行addNumber方式时，要先获取锁，当获取到锁之后并执行到第33行时，线程t1会在此等候第二个线程t2的到来，此时由于线程t1无法释放锁，线程t2一直处于阻塞状态，这时，就出现了死锁情况。

勤奋创造幸福但方向要正确
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合容器面试题（2020最新版）-重点.pdf
11-25
4. 线程安全：某些集合类如Vector和HashTable是线程安全的，但大多数集合类如ArrayList、HashMap不是。为了在多线程环境下保证安全，可以使用Collections.synchronizedXXX方法同步集合，或者使用ConcurrentHashMap等...
Java线程安全与非线程安全解析
08-29
输出结果发现，并不是每次测试结果都是100000，有好几次测试最后ArrayList的size小于100000，甚至时不时会抛出个IndexOutOfBoundsException异常。 七、线程安全的实现 线程安全的实现方式有很多，例如使用同步块、...
Java并发容器总结
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-06 1642
我们日常开发会经常用到各种容器类，容器类为我们提供了大量简化数据操作的API,提高了我们的数据处理的效率。虽然说容器类使用十分方便，但是在多线程情况下，容器类使用不当可能导致线程安全问题，所以Java设计者们为我们提供线程安全操作的并发容器类解决这些问题。但是使用并发容器就真的完全可以避免线程安全问题了吗？它们使用的几个注意事项不知道你是否了解过，这篇文章我们就会基于Map和List两个比较常用的容器类来展开问题的探讨。
Vector线程同步问题
随机事件
07-11 920
方法一：heads.reserve(2000);方法二：加锁：1头文件#include &lt;pthread.h&gt;2全局定义pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 3使用时：pthread_mutex_lock(&amp;mutex);...pthread_mutex_unlock(&amp;mutex); 4使用完毕pthre...
Vector的线程安全与线程不安全
weixin_37990128的博客
11-20 1219
其实这个标题就有点猎奇了。其实对于大多数人来说，线程安全线程不安全，听起来更像是一种编码理论，实际并不会用到，而对于现在的Java程序员来说更是如此，层出不穷的框架早就帮我们明里暗里处理好了线程安全的问题，但是，我还是觉得有必要了解这些东西。 其实对于Vector来说，大多数人可能比较陌生，知道的最多的就是面试的时候要说出它和ArrayList的区别，即一个是线程安全的一个不是，仅此而已，今天翻到别人写的代码，看到了这个vector，一时间没看懂这是啥玩意，花了几分钟了解了一下，觉得还是很有意思的，就给大家
_Java-集合容器-2.List及其实现类.ppt
11-20
- Vector：类似于ArrayList，但在多线程环境中提供同步支持，但通常不推荐使用，因为它的性能较差。 - Stack：Stack是List接口的一个子接口，它实现了后进先出（LIFO）的数据结构，相当于一个堆栈。 学习List接口...
Java从同步容器到并发容器的操作过程
08-26
同步容器，如`Vector`和`HashTable`，通过在每个方法上添加`synchronized`关键字实现了线程安全，但这种方式存在性能瓶颈，因为每次操作都需要锁定整个容器，不适合高并发场景。此外，对于涉及多个步骤的复合操作，...
Java容器类的深入理解
09-05
Java容器类是Java编程中非常重要的一部分，它们为数据存储提供了丰富的结构和操作。本文主要关注的是Java中的两种主要容器类型：Collection和Map，以及它们的一些具体实现，如List接口下的ArrayList、LinkedList和...
验证QList线程安全性的小程序
04-13
申明：不是原创，不是原创，只是转载。 这是一个来自网上的例子 https://blog.csdn.net/conquerwave/article/details/50962548 (conquerwave的专栏) 用于测试QList的线程安全性，因原作者只给出源代码，没有给出测试结果，这里生成一个QT工程，打开即可编译，内部有ReadME.txt，简要说明
Vector 详解
dreamZhanglx的博客
08-24 416
Vector是实现了List接口的子类 Vector底层也是一个对象数组，维护了一个elementData数组。 Vector是线程同步的，线程安全，Vector类的方法带有synchronized关键字，在开发中考虑线程安全中使用Vector。 总结： 无参构造：初始化默认10，之后2倍扩容。 含参构造：指定大小创建，满后，之后2倍扩容。同时支持指定长度扩容。 capacityIncrement翻译是：容量增加。意思是按照指定长度扩容。 如果没有指定长度扩容时，capacityInc.
容器的线程安全
热门推荐
chyroger的专栏
08-17 1万+
<br />java 的容器线程安全<br />1.HashSet 非线程安全【1】<br /> <br />2.TreeSet 非线程安全 【2】<br />3.LinkedHashSet 非线程安全 【3】<br />4.ArrayList 非线程安全 【4】<br />5.LinkedList 非线程安全 【5】<br />6.HashMap 非线程安全 【6】<br />7.TreeMap 非线程安全 【7】<br />8.LinkedHashMap 非线程安全 【8】<br /> <br />9.
Java中Vector的操作一定是线程安全的嘛？
Oeljeklaus的博客
03-15 5728
Java中Vector的操作一定是线程安全的嘛？ Java中Vector类是JDK1.2加入的遗留集合，其内部的方法主要是通过synchronized关键字进行封装，保证这个类是一个线程安全的类，那么是不是vector的操作一定是线程安全的呢？本文将带你分析不一样的vector。 01 vector简介 首先，我们使用简单的描述vector的重要方法。这里是...
同步容器（如Vector）的所有操作一定是线程安全的吗
weixin_38289612的博客
08-18 262
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、解析二、Vector举例1.同步容器2.同步容器的问题3.并发容器总结 前言 为了方便编写出线程安全的程序，java提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列等。 最常见的同步容器就是Vector和HashTable了，那么同步容器的所有操作都是线程安全的吗？ 本文就来深入分析一下这个问题，一个很容易被忽略的问题。 提示：以下是本篇文章正文内容，下面案例可供参考 一、解析 在java中，同步容器主
vector
xmh_sxh_1314的博客
06-06 468
Vector类 　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。 Stack 类 　　Stack继承自Vector，实现一个后.
stl容器是线程安全
最新发布
03-28
需要注意的是，使用线程安全的STL容器并不能完全解决多线程编程中的所有并发问题，仍然需要合理地设计和管理线程间的同步与通信。此外，使用锁或其他同步机制可能会引入额外的开销和复杂性，需要权衡使用的场景和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值