concurrent

QtConcurrent 实际是一个命名空间，该命名空间提供了高级API，从而可以在不使用低级线程原语（启动线程、线程间同步、锁等）的情况下编写多线程程序。 但是QtConcurrent仅支持接受纯函数或者lambda表达式，不支持信号和槽，如果需要监听任务执行结果可以通过与QFuture和QFutureWatcher配合来达到。 QFuture 类表示异步计算的结果，使用Qt Concurrent框架中的API启用。 要使用信号和插槽与正在运行的任务进行交互，则需要使用QFutureWatcher。 QFutureWatcher 类允许使用信号和插槽监视QFuture。 简单的例子： 通过运行结果可以发现，QtConccurent管理的线程实际是从线程池分配线程资源的，而绑定QFutureWatcher的槽是在主线程中执行的。 在需要单次执行且内部逻辑较简单的时候使用QtConccurrent+QFuture+QFutureWatcher是很方便的，可以减少很多编码工作量，而且在多cpu环境中，QtConccurent也会启用多核。

concurrenthashmap是弱一致的，iterator都是弱一致性的，两者的迭代器的一致性不同的。当删除了第7个元素的时候，B会感知到已删除，所以B的后续迭代都是真实的数据。

ConcurrentHashMap的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。要成为强一致性，就得到处使用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样了。

1、ConcurrentHashMap底层数据结构是一个数组table 2、table数组上挂着单向链表或红黑树 3、new ConcurrentHashMap();如果没有指定长度的话，默认是16，并且数组长度必须是2的n次幂，若自定义初始化的长度不是2的n次幂，那么在初始化数组时，会吧数组长度设置为大于自定义长度的最近的2的n次幂。（如：自定义长度为7，那么实际初始化数组后的长度为8） 4、底层是使用synchronized作为同步锁，并且锁的粒度是数组的具体索引位（有些人称之为分段锁）。 5、Node节点，hash>0，当hash冲突时，会形成一个单向链表挂在数组上。 6、ForwardindNode，继承至Node，其hash=-1，表示当前索引位的数据已经被迁移到新数组上了 7、ReservationNode，继承至Node，其hash=-3，表示当前索引位被占用了（compute方法） 8、TreenBin，继承至Node，其hash=-2，代表当前索引下挂着一颗红黑树 9、lockState为ConcurrentHashMap底层自己实现的基于cas的读写锁，锁粒度是具体的某颗树。当向红黑树进行增，删操作时，首先会先上sync同步锁，然后自平衡的时候会上lockState写锁，当读红黑树的时候，会上lockState读锁，然后判断此时是否有线程正持有写锁，或是否有线程正在等待获取写锁，若有，则读线程会直接去读双向链表，而不是去读红黑树。 10、TreeNode，hash>0，为红黑树具体节点。TreeBin的root代表红黑树的根节点，first代表双向链表的第一个节点 11、双向链表：构建红黑树时还维护了一个双向链表，其目的为：(1)当并发写读同一颗红黑树的时候，读线程判断到有线程正持有写锁，那么会跑去读取双向链表，避免因为并发写读导致读线程等待或阻塞。(2)当扩容的时候，会去遍历双向链表，重新计算节点hash，根据新的hash判断放在新数组的高位还是地位 1、触发扩容的规则： 1）添加完元素后，若判断到当前容器元素个数达到了扩容的阈值（数组长度*0.75），则会触发扩容 2）添加完元素后，所在的单向链表长度>=8，则会转为红黑树，不过在转红黑树之前会判断数组长度是否小于64，若小于64则会触发扩容 2、table为扩容前的数组，nextTable为扩容中创建的新数组，迁移数据完毕后需要将nextTable赋值给table 3、扩容后的数组是元素组长度的2倍 4、ln，hn分别表示高位和低位的链表（高链，低链）。即，扩容时，会用n&h==0来判断元素应该放在新数组的i位置还是i+n位置。n：元素组长度；h：元素hash值；i：元素所在的原数组索引位；。这样就会出现有些元素会被挂在低位，有些元素会被挂在高位，从而达到打散元素的目的。 5、红黑树扩容时，会遍历双向链表，并且计算n&h==0来判断元素放在低位（lo）还是高位（ho），确定完元素的去处之后，会判断分别判断两个双向链表（lo,ho）的长度是否大于6，若大于6则将还是以一颗红黑树的结构挂在数组上，若<=6的话，则转为单向链表，挂在数组上

1.首先看错误代码行：list 初始化了吗或者被赋值了吗，而且list 里的对象必须是string类型的。2.从异常看java.util.ConcurrentModificationException:字面意思并发修改异常。出现该异常一般是检测到对象的并发修改，但不允许这样修改，就会抛出这样的异常。3.当collection接口如list 被一个线程调用那么另一线程就不允许修改collection。

看不到你源码不好说，ConcurrentModificationException这个错误是由于使用for(Object obj:objCollections){}这种语法时，在循环内部对objCollections这个集合对象做修改了而造成的

subList方法返回的List和原来的List共享数据Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.

就在主菜单项里啊。

看不到你源码不好说，ConcurrentModificationException这个错误是由于使用for(Object obj:objCollections){}这种语法时，在循环内部对objCollections这个集合对象做修改了而造成的

多线程场景下使用。最直接的场景就是：热点缓存数据。（整个应用只有一份数据，所有线程都可以访问。同时，只能允许单个线程修改数据）非多线程访问同一资源场景下，不需要使用。

ArrayList 是非线程安全的，这点已经在文档中指出来了。如果你想要一个线程安全的就用 CopyOnWriteArrayList。它在修改时把数据复制一份再来修改，因此后续修改不影响正在跑迭代的其它线程。如果你需要一个同步的就可以直接 List synchronizedList = Collections.synchronizedList(new ArrayList());每种实现类都有它的优势和缺点，按我们的需要选择一个合适的就可以了。

调用子模块时 输出端口只能用wire类型变量进行映射 这是verilog语法规定的不知道你说的“无法实现想要的功能”是指什么 但是如果你需要输出信号是reg类型可以增加一个wire类型中间变量 再把这个中间变量赋值给一个reg类型变量wire a；testmodule tss(dataa,a,clockk);reg registerr;always @ * registerr <= a;

比较vg的pvid，如果一样，说明这个vg是shared，算是concurrent

并行会议

有必要，因为get方法会一直等待资源返回，可以用isDone判断 Future.get()方法会一直阻塞，直到有数据返回，这时候isDone()是true.那么在get()之前判断isDone()是否有必要？如下： if (!future.isCancelled()) { HotelSearchResponse response = ...

backport-util-concurrent.jar并发访问处理端口的工具包。是LCDS的一部分

使用QtConcurrent的代码如下：void MainDialog::on_pushButton_toGrayImage_QConcurrent_clicked(){QFuture<QImage*> future = QtConcurrent::run(this,&MainDialog::processImageByQtConcurrent);//imageAfterProceess 这个指针变量之前被无视，现在终于找到存在感了this->imageAfterProceess = future.result(); //接收处理结果this->showImageInNewWindow(this->imageAfterProceess);//新窗口显示处理后的图像}

有个CopyOnWriteArrayList

java是编程语言里比较难学的一门，如果有心从事编程方向的工作，最好到专业机构学习并有更多的项目实践，更贴近市场，这样更有利于将来的发展。

jar包就是别人已经写好的一些类，然后将这些类进行打包，你可以将这些jar包引入你的项目中，然后就可以直接使用这些jar包中的类和属性了，这些jar包一般都会放在lib目录下的...呵呵

ConcurrentHashMap只是保证本身map的线程安全,不保证你自己写的程序的同步.你可以采用客户端加锁实现同步synchronized(test.chm)

。有并发访问的时候用ConcurrentHashMap，效率比用锁的HashMap好功能上可以，但是毕竟ConcurrentHashMap这种数据结构要复杂些，如果能保证只在单一线程下读写，不会发生并发的读写，那么就可以试用HashMap。ConcurrentHashMap读不加锁，写只加部分锁。在多线程下得高性能读写用比较好。但是这也是要用空间换时间来的。如果我的回答没能帮助您，请继续追问。

因为String不是基础类型，而是对象，且是个Value Object(值对象)。你无法改变一个String对象的内容，你只能用另一个String的对象来替换原有的引用。例如：int i = 0;i++;//改变了原来的值String s = "xxx";//你无法改变原来的值s = "abc";//只能使用另外一个对象来替换因此atomic封装的String没有任何用处。atomic包是工具包，只是提供一个方便处理并发计数、改变标志的工具类，不能替代原来的基础类型和对象使用。

出现Concurrent ModeFailure现象时，解决办法就是要让年老代留有足够的空间，以保证新对象空间的分配。另外在JVM BUG中有提到，JDK1.5_09版本之前，JVM参数-XX:CMSInitiatingOccupancyFraction是无效的，我这里应用环境的版本是JDK1.5_08，从gc日志来看是可以生效的。GC时还有一个常见的错误PromotionFailed，解决办法类似，也是调整年轻代和年老代的比例，还有CMSGC的时机。

最大的区别就是ConcurrentHashMap是线程安全的，hashMap不是线程安全的。为什么线程安全呢：ConcurrentHashMap代码中可以看出，它引入了一个“分段锁”的概念，具体可以理解为把一个大的Map拆分成N个小的HashTable，根据key.hashCode()来决定把key放到哪个HashTable中。在ConcurrentHashMap中，就是把Map分成了N个Segment，put和get的时候，都是现根据key.hashCode()算出放到哪个Segment中：

ConCurrentHashMap 1.8 相比 1.7的话，主要改变为： 下面简单介绍下主要的几个方法的一些区别： JDK1.7中的实现： ConCurrentHashMap 和 HashMap 的put()方法实现基本类似，所以主要讲一下为了实现并发性，ConCurrentHashMap 1.7 有了什么改变 JDK1.8中的实现： JDK1.7中的实现： JDK1.8中的实现： JDK1.7中的实现： JDK1.8中的实现： JDK1.7中的实现： JDK1.8中的实现： 由于没有segment的概念，所以只需要用一个 baseCount 变量来记录ConcurrentHashMap 当前 节点的个数 。

那是因为你线程池没有关闭，所以主线程就不会退出，需要主线程退出只需要调用线程池的shutdown()方法，你的代码可以在main方法的最后一行加上 thr.shutdown(); 就可以了。

uservo user=(uservo)voinfo;String username=user.getUsername();String password=user.getPassword();System.out.println("your username is "+username);System.out.println("your password is "+password);List list = new ArrayList();

使用QtConcurrent的代码如下：void MainDialog::on_pushButton_toGrayImage_QConcurrent_clicked(){ QFuture<QImage*> future = QtConcurrent::run(this,&MainDialog::processImageByQtConcurrent); //imageAfterProceess 这个指针变量之前被无视，现在终于找到存在感了 this->imageAfterProceess = future.result(); //接收处理结果 this->showImageInNewWindow(this->imageAfterProceess);//新窗口显示处理后的图像}

使用QtConcurrent的代码如下：void MainDialog::on_pushButton_toGrayImage_QConcurrent_clicked(){ QFuture<QImage*> future = QtConcurrent::run(this,&MainDialog::processImageByQtConcurrent); //imageAfterProceess 这个指针变量之前被无视，现在终于找到存在感了 this->imageAfterProceess = future.result(); //接收处理结果 this->showImageInNewWindow(this->imageAfterProceess);//新窗口显示处理后的图像}

参考如下内容:ConcurrentHashMap锁的方式是稍微细粒度的。 ConcurrentHashMap将hash表分为16个桶（默认值），诸如get,put,remove等常用操作只锁当前需要用到的桶。试想，原来 只能一个线程进入，现在却能同时16个写线程进入（写线程才需要锁定，而读线程几乎不受限制，之后会提到），并发性的提升是显而易见的。更令人惊讶的是ConcurrentHashMap的读取并发，因为在读取的大多数时候都没有用到锁定，所以读取操作几乎是完全的并发操作，而写操作锁定的粒度又非常细，比起之前又更加快速（这一点在桶更多时表现得更明显些）。只有在求size等操作时才需要锁定整个表。而在迭代时，ConcurrentHashMap使用了不同于传统集合的快速失败迭代器的另一种迭代方式，我们称为弱一致迭代器。在这种迭代方式中，当iterator被创建后集合再发生改变就不再是抛出 ConcurrentModificationException，取而代之的是在改变时new新的数据从而不影响原有的数 据，iterator完成后再将头指针替换为新的数据，这样iterator线程可以使用原来老的数据，而写线程也可以并发的完成改变，更重要的，这保证了多个线程并发执行的连续性和扩展性，是性能提升的关键。下面分析ConcurrentHashMap的源码。主要是分析其中的Segment。因为操作基本上都是在Segment上的。先看Segment内部数据的定义。

Q:ConcurrentHashMap和HashMap的区别是什么？ A: 1.ConcurrentHashMap是线程安全的，HashMap是线程不安全的 2.ConcurrentHashMap不允许Key为null的值插入。而HashMap是可以的 Q:JDK8的ConcurrentHashMap和JDK7的ConcurrentHashMap有什么区别？ A: 1.JDK7的ConcurrentHashMap采用分段锁的策略，将整个数组分成多个segment，对这些segment进行分段加锁，使用的锁是ReentrantLock。而JDK8中的ConcurrentHashMap不采用分段锁的方式，直接使用Synchronized来进行。 2.JDK8中的ConcurrentHashMap新增了红黑树，并且插入用的是尾插法。 3.JDK7中的ConcurrentHashMap进行扩容时，是对当前的segment进行扩容，不会对其他segment有影响。而JDK8中就跟HashMap一样。整体扩容，但是保证线程安全 Q:JDK7中的ConcurrentHashMap是如何扩容的 A:JDK7中对每一段segment进行扩容，每一段segment的扩容跟HashMap保持一致 Q:JDK8中的ConcurrentHashMap是如何扩容的 A:在扩容时，首先会生成一个双倍大小的数组，生成完数组后，线程就会开始转移元素，在扩容的过程中，如果有其他线程在put，那么这个put线程会帮助去进行元素的转移，虽然叫转移，但是其实是基于原数组上的Node信息去生成一个新的Node的，也就是原数组上的Node不会消失，因为在扩容的过程中，如果有其他线程在get也是可以的。 Q:ConcurrentHashMap是如何保证线程安全的 A: 1.在JDK7的时候。ConcurrentHashMap是通过ReentrantLock+CAS+分段思想来保证的并发安全的，在JDK7的ConcurrentHashMap中，首先有一个Segment数组，存的是Segment对象，Segment相当于一个小HashMap，Segment内部有一个HashEntry的数组，也有扩容的阈值，同时Segment继承了ReentrantLock类，同时在Segment中还提供了put，get等方法，比如Segment的put方法在一开始就会去加锁，加到锁之后才会把key,value存到Segment中去，然后释放锁。同时在ConcurrentHashMap的put方法中，会通过CAS的方式把一个Segment对象存到Segment数组的某个位置中。同时因为一个Segment内部存在一个HashEntry数组，所以和HashMap对比来看，相当于分段了，每段里面是一个小的HashMap，每段公用一把锁，同时在ConcurrentHashMap的构造方法中是可以设置分段的数量的，叫做并发级别concurrencyLevel. 2.在JDK8的时候，ConcurrentHashMap是通过synchronized+cas来实现了。在JDK8中只有一个数组，就是Node数组，Node就是key，value，hashcode封装出来的对象，和HashMap中的Entry一样，在JDK8中通过对Node数组的某个index位置的元素进行同步，达到该index位置的并发安全。同时内部也利用了CAS对数组的某个位置进行并发安全的赋值。

如果是python2.x，直接在命令提示符中用pip install futures语句安装，concurrent就可以用了。如果是python3，不用安装也可以用，自带了。参看：https://stackoverflow.com/questions/31086530/importerror-no-module-named-concurrent-futures-process

同时 一致

从源码来窥其一斑！ 我们都知道hashMap不是线程安全的，因为在扩容方法中很容易出现死循环，hashTable使用锁的方式比较简单暴力，几乎在所有操作方法上都加了synchronized锁，导致总体性能很差，concurrentHashmap凭借线程安全且性能优异一直都是高并发中的首选key-value型数据结构； concurrentHashmap的高性能有以下原因： 一，分段锁：jdk8中对concurrentHashmap进行了改进，抛弃了jdk7中新建segment作为分段锁的过程，jdk8中虽沿用了这种分段锁的思想，却直接使用数组中的数据作为 分段锁保证concurrentHashmap在上锁的时候只针对数组下标下的数据进行上锁 （比如如果数组长度为256，那么每次put平均只有1/256的数据被锁），而大多数其他的数据还是能进行正常的增删改操作，无需阻塞等待，这无疑极大的 降低了锁的粒度，提升了性能。 二，红黑树 ：jdk8中引入了红黑树结构，在单个数组下标内的数据达到8以后，会自动转换为红黑树进行存储， 使用大O表示法表示效率的话，红黑树的查找效率为O(log(n))，而链表的效率为O（n） ，当数据量越来越大的时候，红黑树的效率明显好于链表，所以concurrentHashmap性能得到很大提升； 现在我们主要从put方法中的主要方法来分析性能的提升： spread(key.hashCode());//作用是再次哈希，减少冲突 ，源码如下其中涉及到的位运算有 >>> 16：无符号右移16位，空位以0补齐 。 ^:异或运算符-->相同为0，不同为1； &：与运算符-->全1得1，否则0； (h ^ (h >>> 16)) & HASH_BITS; 所以这句代码的意思就是不仅消除高16位的影响，同时获得正整数的hash值 再来看后面的方法， 如上图： 1，就是判断当这个hash表还是空的时候，调用initTable进行初始化； 2，使用(n - 1) & hash)计算数组下标，如果数据指定下标处为null，则直接插入，注： cas是java8中的concurrentHashmap引入的线程安全判断，CAS算法做为乐观锁 ； 3，(fh = f.hash) == MOVED，走到此处说明下标内有node，且该node的值为-1（MODED=-1),搜索全类发现MODED是在调用有参构造器ForwardingNode中默认写入的，而这个调用处刚好在transfer方法中，所以我们推断，扩容的时候先将数组下标内的node.hash置为-1！ 同时在3这一步中调用helpTransfer(tab, f)参与扩容，并把数据写入；4，走到这说明node不是空的，也没在扩容，那么锁住该下标下的node，并把新value插入链表中； 5，如果锁住的这个node能实例化为TreeBin，则代表已经转化为红黑树进行存储，将数据插入红黑树中； 6，判断在4,5中计算得到的数组下标内所有节点总数， 如果满足转化为红黑树的条件（节点数大于8），则自动转化为红黑树进行存储！ 总的来说，concurrentHashmap之所以性能高就是因为使用了分段锁和红黑树！ 至于conrrentHashmap其他的方法的源码分析，后期会补上的，更多的技术分享，敬请关注！

hashmap和concurrenthashmap的区别如下：HashMap不是线程安全的，而ConcurrentHashMap是线程安全的。ConcurrentHashMap采用锁分段技术，将整个Hash桶进行了分段segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段segment上面都有锁存在。那么在插入元素的时候就需要先找到应该插入到哪一个片段segment，然后再在这个片段上面进行插入，而且这里还需要获取segment锁。ConcurrentHashMap让锁的粒度更精细一些，并发性能更好。HashMap：底层数组+链表实现，可以存储null键和null值，线程不安全。初始size为16，扩容：newsize = oldsize*2，size一定为2的n次幂。扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入。插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）。ConcurrentHashMap：底层采用分段的数组+链表实现，线程安全。通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)。Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。

从类图中可以看出来在存储结构中ConcurrentHashMap比HashMap多出了一个类Segment。 ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一个可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似，是一种数组和链表结构。一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素。当对HashEntry数组的数据进行修改时，必须首先获得与它对应的segment锁。 ConcurrentHashMap是使用了锁分段技术来保证线程安全的。 锁分段技术 ：首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。 ConcurrentHashMap提供了与Hashtable和SynchronizedMap不同的锁机制。Hashtable中采用的锁机制是一次锁住整个hash表，从而在同一时刻只能由一个线程对其进行操作；而ConcurrentHashMap中则是一次锁住一个桶。 Hashtable容器在竞争激烈的并发环境下表现出效率低下的原因是因为所有访问Hashtable的线程都必须竞争同一把锁，假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其它段的数据也能被其它线程访问。

concurrentmap线程安全原因：1、JDK1.7中，ConcurrentHashMap使用的锁分段技术，将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。2、JDK1.8放弃了锁分段的做法，采用CAS和synchronized方式处理并发。以put操作为例，CAS方式确定key的数组下标，synchronized保证链表节点的同步效果。

在并发使用到HashMap的时候，往往不建议直接用HashMap，因为HashMap在并发写数据的时候容易因为rehash的过程产生环形链表的情况。所以在并发使用Map结构时，一般建议使用ConcurrentHashMap。 在JDK1.7中ConcurrentHashMap采用了 数组+Segment+分段锁 的方式实现。 从上面的结构我们可以了解到，ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作。第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部。 JDK8中ConcurrentHashMap参考了JDK8 HashMap的实现，采用了数组+链表+红黑树的实现方式来设计，内部大量采用CAS操作。并发控制使u2f64 synchronized 和 CAS 来操作。 （JDK1.6 以后 对 synchronized 锁做了很多优化） 整个看起来就像是优化过且线程安全的 HashMap，虽然在 JDK1.8 中还能看到 Segment 的数据结构，但 是已经简化了属性，只是为了兼容旧版本； JDK1.8的Nod节点中value和next都用volatile修饰，保证并发的可见性。 可以理解为，synchronized 只锁定当前链表或红u2fcau2f06叉树的u2fb8节点，这样只要 hash 不冲突，就不会产u2f63并发，效率u2f1c提升 N 倍。 Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采u2f64 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突u2f7d存在的； Hashtable(同u2f00把锁) :使u2f64 synchronized 来保证线程安全，效率u2fae常低下。当u2f00个线程访问同步u2f45法时，其他线程也访问同步u2f45法，可能会进u2f0a阻塞或轮询状态，如使u2f64 put 添加元素，另u2f00个线程不能使u2f64 put 添加元素，也不能使u2f64get，竞争会越来越激烈效率越低； 总结一下： JavaGuide

concurrent [ku0259n"ku028cru0259nt] adj. 并发的；一致的；同时发生的n. 共点；同时发生的事件simultaneous [,simu0259l"teiniu0259s] adj. 同时的；联立的；同时发生的n. 同时译员

concurrentadj.〈正式〉同时发生的; 同时完成的; 同时存在的; n.[数] 共点; 同时发生的事件; **************************************************************如果你对这个答案有什么疑问，请追问，另外如果你觉得我的回答对你有所帮助，请千万别忘记采纳哟！***************************************************************

兼职教授

uservo user=(uservo)voinfo;String username=user.getUsername();String password=user.getPassword();System.out.println("your username is "+username);System.out.println("your password is "+password);List list = new ArrayList();