ublic class
ConcurrentLinkedQueue
extends AbstractQueue<E>
implements Serializable Queue<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
java.util.concurrent.ConcurrentLinkedQueue<E>
Class Overview
An unbounded thread-safe queue based on linked nodes. This queue orders elements FIFO (first-in-first-out).
The head of the queue is that element that has been on the queue the longest time.
The tail of the queue is that element that has been on the queue the shortest time.
New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue.
A ConcurrentLinkedQueue is an appropriate choice when many threads will share access to a common collection.
This queue does not permit null elements.
它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的,尾是最近加入的。
插入元素是追加到尾上。提取一个元素是从头提取。当多个线程共享访问一个公共 collection 时,ConcurrentLinkedQueue 是一个恰当的选择。该队列不允许null元素。
This implementation employs an efficient "wait-free" algorithm based on one described in Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms by .
此实现采用了有效的“无等待 (wait-free)”算法,该算法基于 Maged M. Michael 和 Michael L. Scott 合著的 Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms 中描述的算法。
Beware that, unlike in most collections, the size method is NOT a constant-time operation. Because of the asynchronous nature of these queues,
determining the current number of elements requires a traversal of the elements.
注意和大多数集合不一样。得到元素个数所花的时间是不确定。由于该队列的异步特性,确定当前的元素数量需要遍历的元素。
This class and its iterator implement all of the optional methods of the Collection and Iterator interfaces.
这个类和它的迭代器实现了Collection和Iterator接口的所有可选方法。
Memory consistency effects: As with other concurrent collections,
actions in a thread prior to placing an object into a ConcurrentLinkedQueue happen-before actions subsequent to the access or removal of that element from the ConcurrentLinkedQueue in another thread.
内存一致性效果:和其他并发集合一样。把一个元素放入到队列的线程的优先级高与对元素的访问和移除的线程。
有三个函数需要注意的:
E peek()
Gets but does not remove the element at the head of the queue.
E poll()
Gets and removes the element at the head of the queue, or returns null if there is no element in the queue.
public <T> T[] toArray(T[] a)
返回以恰当顺序包含此队列所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。如果指定的数组能容纳队列,则将该队列返回此处。否则,将分配一个具有指定数组的运行时类型和此队列大小的新数组。
如果指定的数组能容纳队列,并有剩余的空间(即数组的元素比队列多),那么会将紧接队列尾部的元素设置为 null。
像 toArray() 方法一样,此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。更进一步说,此方法允许对输出数组的运行时类型进行精确控制,在某些情况下,这可以用来节省分配开销。
假定 x 是只包含字符串的一个已知队列。以下代码用来将该队列转储到一个新分配的 String 数组:
String[] y = x.toArray(new String[0]);
注意,toArray(new Object[0]) 和 toArray() 在功能上是相同的。
指定者:
接口 Collection<E> 中的 toArray
覆盖:
类 AbstractCollection<E> 中的 toArray
参数:
a - 将用来存储队列元素的数组(如果该数组足够大);否则,将为此分配一个具有相同运行时类型的新数组
返回:
包含此队列所有元素的数组
抛出:
ArrayStoreException - 如果指定数组的运行时类型不是此队列中每个元素的运行时类型的超类型
NullPointerException - 如果指定数组为 null
size
public int size()
返回此队列中的元素数量。如果此队列包含的元素数大于 Integer.MAX_VALUE,则返回 Integer.MAX_VALUE。
需要小心的是,与大多数 collection 不同,此方法不是 一个固定时间操作。由于这些队列的异步特性,确定当前的元素数需要进行一次花费 O(n) 时间的遍历。
指定者:
接口 Collection<E> 中的 size
指定者:
类 AbstractCollection<E> 中的 size
返回:
此队列中的元素数
注意1:
ConcurrentLinkedQueue的.size() 是要遍历一遍集合的,很慢的,所以尽量要避免用size,
如果判断队列是否为空最好用isEmpty()而不是用size来判断.
注意问题1:
使用了这个ConcurrentLinkedQueue 类之后是否意味着我们不需要自己进行任何同步或加锁操作了呢?
我在网上找到了这个:http://stackoverflow.com/questions/435069/java-util-concurrentlinkedqueue/435941 // StackOverflow果然是个好地方啊……
也就是说,如果直接使用它提供的函数,比如:queue.add(obj); 或者 queue.poll(obj);,这样我们自己不需要做任何同步。
但如果是非原子操作,比如:
1. if(!queue.isEmpty()) {
2. queue.poll(obj);
3. }
我们很难保证,在调用了isEmpty()之后,poll()之前,这个queue没有被其他线程修改。
所以对于这种情况,我们还是需要自己同步:
1. synchronized(queue) {
2. if(!queue.isEmpty()) {
3. queue.poll(obj);
4. }
5. }
注意问题2:
主类
Java代码
1. public class conn{
2. public static void main(String[] args) throws Exception{
3. Queue<String> queue=new ConcurrentLinkedQueue<String>();
4. for(int i=0;i<1000000;i++){
5. queue.add(String.valueOf(i));
6. }
7. int num=10;//线程人个数
8. for(int i=0;i<num;i++){
9. new ThreadConn(queue);
10. }
11.
12. }
13. }
线程类
Java代码
1. public class ThreadConn implements Runnable{
2. Queue<String> queue;
3. public ThreadConn(Queue<String> queue){
4. this.queue=queue;
5. Thread thread=new Thread(this);
6. thread.start();
7. }
8. public void run(){
9. try{
10. long sd=new Date().getTime();
11. while(queue.poll()!=null){
12. //这里是业务逻辑
13. }
14. System.out.println (sn-sd);
15. }catch(Exception e){
16. e.printStackTrace();
17. }
18. }
19. }
测试结果如下:
启动10个线程
31
0
0
0
0
500
390
297
0
0
启动1个线程
360
分享到:
相关推荐
3. **并发容器**:如`ConcurrentHashMap`, `ConcurrentLinkedQueue`, `CopyOnWriteArrayList`等,它们提供了线程安全的数据结构。 4. **原子操作类**:`java.util.concurrent.atomic`包中的类,如`AtomicInteger`, `...
15.并发容器之ConcurrentLinkedQueue 16.并发容器之CopyOnWriteArrayList 17.并发容器之ThreadLocal 18.一篇文章,从源码深入详解ThreadLocal内存泄漏问题 19.并发容器之BlockingQueue 20.并发容器之...
这涉及到Java并发编程的核心概念,包括 volatile 变量、原子变量类(`Atomic*`)、线程安全的数据结构(如 `ConcurrentHashMap`)以及并发集合(`CopyOnWriteArrayList` 和 `ConcurrentLinkedQueue` 等)。...
这个链接的内容可能包括最佳实践、避免的陷阱以及与其他线程安全集合类(如CopyOnWriteArrayList或ConcurrentLinkedQueue)的比较。 在Java中,了解如何正确地处理并发集合是非常关键的技能,因为错误的使用可能会...
8. **并发集合**:Java并发库(java.util.concurrent)提供了线程安全的集合实现,如ConcurrentHashMap、CopyOnWriteArrayList和ConcurrentLinkedQueue,它们在多线程环境下性能更优。 9. **流(Stream)API**:...
- 并发集合:ConcurrentHashMap,ConcurrentLinkedQueue,CopyOnWriteArrayList等 2. **Chapter 4** - 高级I/O流 - NIO(New IO):通道(Channels),缓冲区(Buffers),选择器(Selectors) - 文件系统操作:...
`ConcurrentLinkedQueue`是一个无界的并发队列,基于链接节点实现,提供了高并发性能。 9. **集合转换与集合工具类**:`Collections`工具类提供了许多静态方法,如对集合进行排序、反转、查找、填充等操作。此外,...
4. **并发容器**:ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue等并发容器的使用,它们是如何保证线程安全的。 5. **线程优先级**:了解Java线程的优先级模型,以及它在实际应用中的作用和限制...
需要注意的是,虽然这个例子中使用了线程安全的 `List`,但在实际应用中,如果多线程环境中的排序操作是独立的,可以考虑使用并发集合,如 `ConcurrentSkipListSet` 或 `ConcurrentLinkedQueue`,它们在性能上可能更...
4. 并发容器:Java并发工具包还提供了很多线程安全的集合类,如ConcurrentMap、ConcurrentLinkedQueue、BlockingQueue以及CopyOnWriteArrayList和CopyOnWriteArraySet等。这些容器类在设计上充分考虑了并发环境下的...
- ConcurrentHashMap、ConcurrentLinkedQueue等容器是线程安全的,它们在并发环境下提供高效且线程安全的操作。 - 使用Collections.synchronizedXXX()方法将非线程安全的容器转换为线程安全的容器,但性能可能较低...
书中还可能涉及并发集合,如ConcurrentHashMap、CopyOnWriteArrayList和ConcurrentLinkedQueue等。这些集合类在内部采用了高级并发策略,能够在多线程环境下提供高性能和线程安全的访问。 另外,线程间的通信也是...
- **优化队列实现**:考虑到`LinkedBlockingQueue`在多核环境下的表现不佳,可以探索使用更高效的队列实现方式,比如`ConcurrentLinkedQueue`或自定义的无锁队列,以减少锁的竞争和缓存未命中的次数。 - **减少字符...
在多线程环境下,Java提供了并发安全的集合实现,如`ConcurrentHashMap`, `CopyOnWriteArrayList`, `ConcurrentLinkedQueue`等,这些类在保证线程安全的同时,尽可能减少了同步开销。 10. **流(Stream) API** ...
此外,书中还会涵盖并发容器,如ArrayList、LinkedList、Vector、Stack、ConcurrentHashMap、ConcurrentLinkedQueue等。这些容器在并发环境下的性能和线程安全性各不相同,选择合适的容器对于优化并发程序性能至关...
并发容器ConcurrentLinkedQueue原理与使用.mp4 Java中的阻塞队列原理与使用.mp4 实战:简单实现消息队列.mp4 并发容器ConcurrentHashMap原理与使用.mp4 线程池的原理与使用.mp4 Executor框架详解.mp4 实战:简易web...
此外,对于大数据量的情况,考虑使用并发集合,如ConcurrentLinkedQueue或CopyOnWriteArrayList,以提高多线程环境下的性能。 总的来说,理解ArrayList和LinkedList的基本特性和应用场景,以及如何处理与之相关的...
- **并发集合**:如ConcurrentHashMap、ConcurrentLinkedQueue等。 4. **JVM** - **内存模型**:堆内存、栈内存、方法区,以及垃圾回收机制。 - **类加载机制**:双亲委派模型,类加载器的层次关系。 - **性能...
19. **并发容器**:除了ConcurrentHashMap,还有ConcurrentLinkedQueue、ConcurrentSkipListMap和ConcurrentSkipListSet等并发容器,适用于高并发场景。 20. **集合与数组的转换**:toArray()方法可以将集合转换...
2. 并发容器:ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue等是专门为并发设计的高效容器。 四、线程池 1. Executor框架:Java提供的线程池API,通过ThreadPoolExecutor实现,可以管理线程的...