Vector线程安全

最新推荐文章于 2023-06-10 23:34:10 发布
最新推荐文章于 2023-06-10 23:34:10 发布
阅读量1.3k 收藏
点赞数
分类专栏： java-8学习记录 文章标签： 线程安全 vector 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JQ_AK47/article/details/47423725
版权

vector虽然所有方法都是同步的，线程安全的。但是这个对于我们编程也不是一定线程安全的。当然这是有条件的。
比如有一个
Vector vectorOfEnemyTank; 变量，这个变量是对象属性级别的。

一个线程方法

public boolean isTouchOtherTanke()
{
.......
EnemyTank ee = getEnemyTankOfCount.get(i);
.........
}

这里的getEnemyTankOfCount变量是vectorOfEnemyTank变量的引用， 每创建一个对象，他都指向相同的同一个向量空间，这个向量空间就是vectorOfEnemyTank。

但是如果现在有十个线程，同时调用isTouchOtherTanke方法，那么相当于十个线程同时操作同一个向量空间，每个线程都是通过getEnemyTankOfCount向量引用操作同一个向量空间。那么这里可能因为线程1对vectorOfEnemyTank的向量空间操作，而线程2并不知道这个情况，那么发生遍历Vector的时候就可能发生数组越界的错误。
综上结语：对vector向量元素的操作方法是线程安全的，但是当把这些方法组合在一起，在两个方法被执行的间隙，可能由其他线程获得对象锁，从而改变了属性的状态；这个时候在执行线程的另外一个方法可能就会发生错误了。比如上面这个例子可能发生的错误是数组越界。

//源码如下

 /**
     * @author pengrong
     * @return
     * @功能：被坦克调用以判定坦克和面板中其他坦克是不是碰撞了;
     * @author pengrong  重大功能更改，这个函数表示的是面板上所有的坦克线程都会调用的。
     * 访问的是面板上的同一个集合变量 Vector<EnemyTank> vectorOfEnemyTank。注意哦是同一个啊，所以要同步，不然会发生数组越界的风险
     * 初步打算是把这个方法改造成类同步规则,所以每个坦克都要传递两个参赛，1、代表自己的坦克引用，保存有所有面板坦克的vector变量。
     */
    public synchronized static boolean isTouchOtherTank(EnemyTank et, Vector<EnemyTank> getEnemyTankOfCount) 
    {
        if (getEnemyTankOfCount ==null) {
            return false;

        }
        boolean isTrue =false;
        int X1,Y1,X2,Y2;
        switch ( et.getDierction() ) 
        {
            //我的坦克向上 
            case 0:
                /**
                 * 定义X1,Y1；用于界定坦克的另外三个点的坐标
                 */

                X1 = et.getAxisX() + 33;
                Y1 = et.getAxisY() + 53;
                for (int i = 0; i < getEnemyTankOfCount.size(); i++) 
                {
                    //取到的坦克元素可能是自己
                    EnemyTank ee = getEnemyTankOfCount.get(i);
                    //如果ee的方向是往上或者往下的
                    if ( (ee.getDierction() ==0) || (ee.getDierction() == 2)) 
                    {
                        X2 =ee.getAxisX() +33;
                        Y2 =ee.getAxisY() +53;
                    }
                    else 
                    {
                        X2 = ee.getAxisX() + 53;
                        Y2 = ee.getAxisY() + 33;
                    }

                    /**
                     * 如果坦克ee不是自己，同时还活着
                     */
                    if ((ee != et) && (ee.isLive() ==true) ) 
                    {

                        /**
                         * 根据 我方坦克的上面左右两个顶点和坦克相比较得出是否相撞，并且改变方向
                         */
                            //待比较坦克方向是向上/向下/想左/向右的
                                    //从坦克向上方向判断是否有与之相撞
                                    if ( ( et.getAxisX() >= ee.getAxisX() ) && ( et.getAxisX() <= X2 ) &&
                                         ( et.getAxisY() >= ee.getAxisY() ) && ( et.getAxisY() <= Y2 ) ) 
                                    {

                                        isTrue =true;
                                    }
                                    if ( ( X1 >= ee.getAxisX() ) && ( X1 <= X2 ) &&
                                         ( et.getAxisY() >= ee.getAxisY() ) && ( et.getAxisY() <= Y2 ) ) 
                                    {
                                        isTrue =true;
                                    }

                                    //从坦克的下方判断是否有与之相撞的坦克
                                    if ( ( et.getAxisY() < ee.getAxisY() ) && ( ee.getAxisY() < Y1 ) ) 
                                    {
                                        isTrue =true;

                                    }
                                    //如果相撞了才需要设置坦克的新方向。这一点需要注意;设置自己方向改变
                                    if ( isTrue == true ) 
                                    {
                                        //this.setDierction(2);
                                    }

                    }

                }
                break;
                //我方坦克向下
            case 2:

                /**
                 * 定义X1,Y1；用于界定坦克的另外三个点的坐标
                 */

                X1 = et.getAxisX() + 33;
                Y1 = et.getAxisY() + 53;
                for (int i = 0; i < getEnemyTankOfCount.size(); i++) 
                {
                    //取到的坦克元素可能是自己
                    EnemyTank ee = getEnemyTankOfCount.get(i);
                    //如果ee的方向是往上或者往下的
                    if ( (ee.getDierction() ==0) || (ee.getDierction() == 2)) 
                    {
                        X2 =ee.getAxisX() +33;
                        Y2 =ee.getAxisY() +53;
                    }
                    else 
                    {
                        X2 = ee.getAxisX() + 53;
                        Y2 = ee.getAxisY() + 33;
                    }

                    /**
                     * 如果坦克ee不是自己，同时还活着
                     */
                    if ((ee != et) && (ee.isLive() ==true) ) 
                    {

                        /**
                         * 根据 我方坦克的上面左右两个顶点和坦克相比较得出是否相撞，并且改变方向
                         */
                            //待比较坦克方向是向上/向下/想左/向右的
                                    //从坦克前进方向判断
                                    if ( ( et.getAxisX() >= ee.getAxisX() ) && ( et.getAxisX() <= X2 ) &&
                                         ( Y1 >= ee.getAxisY() ) && ( Y1 <= Y2 ) ) 
                                    {

                                        isTrue =true;
                                    }
                                    if ( ( X1 >= ee.getAxisX() ) && ( X1 <= X2 ) &&
                                         ( Y1 >= ee.getAxisY() ) && ( Y1 <= Y2 ) ) 
                                    {
                                        isTrue =true;
                                    }

                                    //从坦克前进方向的上面判断是否有相撞
                                    if ( ( et.getAxisY() < Y1 ) && ( Y1 < Y2 ) ) 
                                    {
                                        isTrue =true;
                                    }
                                    //如果相撞了才需要设置坦克的新方向。这一点需要注意;设置自己方向改变
                                    if ( isTrue == true ) 
                                    {
                                        //this.setDierction(0);
                                    }

                    }

                }
                break;
            //我方坦克向右    
            case 1 :
                /**
                 * 定义X1,Y1；用于界定坦克的另外三个点的坐标
                 */

                X1 = et.getAxisX() + 53;
                Y1 = et.getAxisY() + 33;
                for (int i = 0; i < getEnemyTankOfCount.size(); i++) 
                {
                    //取到的坦克元素可能是自己
                    EnemyTank ee = getEnemyTankOfCount.get(i);
                    //如果ee的方向是往上或者往下的
                    if ( (ee.getDierction() ==0) || (ee.getDierction() == 2)) 
                    {
                        X2 =ee.getAxisX() +33;
                        Y2 =ee.getAxisY() +53;
                    }
                    else 
                    {
                        X2 = ee.getAxisX() + 53;
                        Y2 = ee.getAxisY() + 33;
                    }

                    /**
                     * 如果坦克ee不是自己，同时还活着
                     */
                    if ((ee != et) && (ee.isLive() ==true) ) 
                    {

                        /**
                         * 根据 我方坦克的上面左右两个顶点和坦克相比较得出是否相撞，并且改变方向
                         */
                            //待比较坦克方向是向上/向下/想左/向右的
                                    //从坦克前进方向判断是否相撞
                                    if ( ( X1 >= ee.getAxisX() ) && ( X1 <= X2 ) &&
                                         ( et.getAxisY() >= ee.getAxisY() ) && ( et.getAxisY() <= Y2 ) ) 
                                    {

                                        isTrue =true;
                                    }
                                    if ( ( X1 >= ee.getAxisX() ) && ( X1 <= X2 ) &&
                                         ( Y1 >= ee.getAxisY() ) && ( Y1 <= Y2 ) ) 
                                    {
                                        isTrue =true;
                                    }
                                    //从坦克前进方向的后面
                                    if ( ( et.getAxisX() < X2 ) && ( X2 < X1 ) ) 
                                    {
                                        isTrue =true;
                                    }
                                    //如果相撞了才需要设置坦克的新方向。这一点需要注意;设置自己方向改变
                                    if ( isTrue == true ) 
                                    {
                                        //this.setDierction(3);
                                    }

                    }

                }
                break;

                //我方坦克向左
            case 3: 
                /**
                 * 定义X1,Y1；用于界定坦克的另外三个点的坐标
                 */

                X1 = et.getAxisX() + 53;
                Y1 = et.getAxisY() + 33;
                for (int i = 0; i < getEnemyTankOfCount.size(); i++) 
                {
                    //取到的坦克元素可能是自己
                    EnemyTank ee = getEnemyTankOfCount.get(i);
                    //如果ee的方向是往上或者往下的
                    if ( (ee.getDierction() ==0) || (ee.getDierction() == 2)) 
                    {
                        X2 =ee.getAxisX() +33;
                        Y2 =ee.getAxisY() +53;
                    }
                    else 
                    {
                        X2 = ee.getAxisX() + 53;
                        Y2 = ee.getAxisY() + 33;
                    }

                    /**
                     * 如果坦克ee不是自己，同时还活着
                     */
                    if ((ee != et) && (ee.isLive() ==true) ) 
                    {

                        /**
                         * 根据 我方坦克的上面左右两个顶点和坦克相比较得出是否相撞，并且改变方向
                         */
                            //待比较坦克方向是向上/向下/想左/向右的
                                    //坦克前进方向碰撞到了坦克
                                    if ( ( et.getAxisX() >= ee.getAxisX() ) && ( et.getAxisX() <= X2 ) &&
                                         ( et.getAxisY() >= ee.getAxisY() ) && ( et.getAxisY() <= Y2 ) ) 
                                    {

                                        isTrue =true;
                                    }
                                    if ( ( et.getAxisX() >= ee.getAxisX() ) && ( et.getAxisX() <= X2 ) &&
                                         ( Y1 >= ee.getAxisY() ) && ( Y1 <= Y2 ) ) 
                                    {
                                        isTrue =true;
                                    }

                                    //在坦克后面碰到了坦克
                                    if ( ( et.getAxisX() < ee.getAxisX() ) && ( ee.getAxisX() < X1 ) )
                                    {
                                        isTrue =true;
                                    }
                                    //如果相撞了才需要设置坦克的新方向。这一点需要注意;设置自己方向改变
                                    if ( isTrue == true ) 
                                    {
                                        //this.setDierction(1);
                                    }


                    }

                } 

                break;

            default:
                break;
        }

        return isTrue;

    }
JQ_AK47
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现线程安全的vector
琅嬛福地
11-20 356
如果你需要支持迭代器，你可能需要使用一个不同的设计，例如，你可以返回一个持有锁的“代理”对象，该对象在析构函数中释放锁。的每个操作都是线程安全的，但如果你需要进行多个操作并且这些操作需要一起原子地（atomically）完成，那么你可能需要在你的代码中添加额外的同步。如果你的应用程序需要更高的并行性，你可能需要使用更复杂的数据结构或同步策略，例如，你可以使用一个并行数据结构库，或者实现一个读写锁策略，允许多个线程同时读取vector。方法，因为在调用这两个方法之间，其他线程可能已经修改了vector。
线程安全Vector
07-13
线程安全!~~涉及到vector的操作问题，以及在多线程中应该注意的事项.
std string与线程安全_C++ STL容器如何解决线程安全的问题？
weixin_35714577的博客
01-30 1548
众所周知，STL容器不是线程安全的。对于vector，即使写方(生产者)是单线程写入，但是并发读的时候，由于潜在的内存重新申请和对象复制问题，会导致读方(消费者)的迭代器失效。实际表现也就是招致了core dump。另外一种情况，如果是多个写方，并发的push_back()，也会导致core dump。解法一：加锁是一种解决方案，但是加std::mutex互斥锁确实性能较差。对于多读少写的场景可以...
HashMap，Vector，Hashtable，ConcurrentHashMap等并发容器线程安全的进化过程
calm_encode的博客
09-28 787
一 概述 二 Vector Vector线程安全的集合类，同时它是基于动态数组实现的集合类，借助Synchronized修饰的方法来保证多线程安全。在Vector集合类中Synchronized加在方法上，性能会比较差。 三 通过Collections中的指定方法保证线程安全 ArrayList和HashMap为线程不安全的集合类，我们可以通过Collections中提供的方法使得其能够在多线程的情况下保持线程安全。 Collections.synchronizedList(new Array
探索C++并发容器：std::vector的线程安全性
夏天的狂风的专栏
06-10 2078
std::vector是C++标准库中的一个动态数组，它可以存储任何类型的元素，并且可以在运行时动态地增加或减少其大小。std::vector提供了一种高效的方式来管理和操作数组，它提供了一组丰富的函数，如push_back、pop_back、insert、erase等，用于添加、删除和修改元素。
原创 | 面试官问我同步容器（如Vector）的所有操作一定是线程安全的吗？我懵了！...
HollisChuang's Blog
08-26 2213
△Hollis, 一个对Coding有着独特追求的人△这是Hollis的第226篇原创分享作者 l Hollis来源 l Hollis（ID：hollischuang）...
关于Vector到底是不是 线程安全的 问题
weixin_30633949的博客
04-04 1847
线程安全，在java的多并发编程中是重要概念，意思是，多个线程同时操作一个对象，在各种不同情况下，都不会造成不同的后果。 一个经典问题，Vector到底是不是线程安全的？ 很多人都会回答，是，vector是线程安全的。 诚然，不止是很多IT教材上是这么写的，就连JDK的作者写的注释也是这么说的。如下图（图为 JDK中Vector的源代码）：注释中，红框标记的部分写着：如果你不需要线程安...
线程安全-关于vector
温水青蛙
06-21 1497
Vector 是线程安全的，是不是在多线程下操作Vector就可以不用加Synchronized 如标题一样，如果之前让我回答，我会说，是的，在多线程的环境下操作Vector，不需要加Synchronized。 但是我今天无意间看到一篇文章，我才发现我之前的想法是错误的，这篇文章的地址： http://zhangbq168.blog.163.com/blog/static
Vector真的是线程安全的吗
Reborn_Chang的博客
07-01 2105
转载请标明出处^_^ 原文首发于：www.zhangruibin.com 本文出自于：RebornChang的博客 Vector真的是线程安全的吗 Vector类 继承了 AbstractList<E> 实现了 List<E>, RandomAccess, Cloneable, java.io.Serializable接口。 AbstractList 类 继承了 A...
Java集合多线程安全.docx
07-10
Java集合多线程安全 线程安全与不安全集合 线程不安全集合： ArrayList LinkedList HashMap HashSet TreeMap TreeSet StringBulider 线程安全集合： Vector HashTable Properties 集合线程安全...
vector线程中的应用
07-13
关于线程安全的介绍，vector的线程安全性，vector的相关操作。线程安全性的操作.
srzyhead#ReadingNote#13-线程安全与锁优化1
07-25
绝对线程安全Vector的get()、remove()和size()，如果另一个线程恰好在错误的时间里删除了一个元素,导致序号i已经不再可用的话,再用i访问数组
java集合-Vector的使用
06-14
但需要注意的是，Vector是线程安全的，在多线程环境下可以进行并发操作。如果不需要线程安全性，并且希望更高的性能，可以使用ArrayList。 需要注意的是，从Java 1.2开始，推荐使用ArrayList代替Vector，因为...
Java中Vector的操作一定是线程安全的嘛？
Oeljeklaus的博客
03-15 5702
Java中Vector的操作一定是线程安全的嘛？ Java中Vector类是JDK1.2加入的遗留集合，其内部的方法主要是通过synchronized关键字进行封装，保证这个类是一个线程安全的类，那么是不是vector的操作一定是线程安全的呢？本文将带你分析不一样的vector。 01 vector简介 首先，我们使用简单的描述vector的重要方法。这里是...
C++编程 –安全并发访问容器元素
热门推荐
flyfish
09-24 1万+
C++ 安全并发访问容器元素 2014-9-24 flyfish 标准库STL的vector, deque, list等等不是线程安全的 例如  线程1正在使用迭代器（iterator）读vector 线程2正在对该vector进行插入操作，使vector重新分配内存，这样就造成线程1中的迭代器失效 STL的容器 多个线程读是安全的，在读的过程中，不能对容器有任何写入操作
HashTable、Vector、StringBuffer线程安全的原因
旧城以西的博客
12-31 2742
一、HashTable线程安全的原因：put方法是synchronized的所以可以保证其线程安全 二、Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe),但有些时候，也甭保证，比如： Vector test = Vector(); ....... ....... for (i = 0; i < test.size(); i++
[多线程并发并行]_[C/C++11]_[多线程访问修改集合vector会冲突的两个解决方案]
Tobey(我是机器人)
06-21 2998
1. 在开发`C/C++`多线程程序时,`STL`集合类是我们经常用到的类，比如`vector`. 而`C/C++`的这些集合类并没有同步版本，所以在多线程访问时，如果某个线程正在修改集合类`A`, 而其他线程正在访问`A`，那么会造成数据冲突，导致程序抛出异常。这里说的访问`A`,意思是调用`A`的任何方法。难道我们需要在用到`A`的地方对`A`进行加锁？ 麻烦不止，而且很容易造成性能下降。
C++并发编程下栈和队列的线程安全代码 及 注释
qq_54151629的博客
03-28 167
写的很清晰了 stack和queue直接看对应的注释应该能看懂。消失的拷贝赋值函数是为了解决数据冲突。削减的接口有一部分为了解决接口冲突。queue的线程安全实现方法。stack的线程安全代码。
vector线程安全
最新发布
07-29
Vector是一个线程安全的类，它的方法都是同步的，并且明确设计为在多线程环境中工作。然而，它的线程安全性是有限制的。在某些方法之间存在状态依赖，如果在迭代过程中Vector被其他线程修改，通过Vector.iterator()...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值