TransactionalLinkedList (The Multiverse core package 0.4 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.multiverse.transactional.collections
Class TransactionalLinkedList<E>

java.lang.Object
  java.util.AbstractCollection<E>
      org.multiverse.transactional.collections.AbstractBlockingDeque<E>
          org.multiverse.transactional.collections.TransactionalLinkedList<E>


Type Parameters:: E -

All Implemented Interfaces:: java.lang.Iterable<E>, java.util.Collection<E>, java.util.concurrent.BlockingDeque<E>, java.util.concurrent.BlockingQueue<E>, java.util.Deque<E>, java.util.List<E>, java.util.Queue<E>

public class TransactionalLinkedList<E>
extends AbstractBlockingDeque<E>
implements java.util.List<E>
extends AbstractBlockingDeque<E>
implements java.util.List<E>

A general purposes collection structure that could be considered a work horse because it implements a lot of interfaces:

Iterable

Collection

List

Queue

BlockingQueue

Deque

BlockingDeque

Each operation on this TransactionalLinkedList is transactional by default, and of course can participate in already running transactions.

There is a scalability issue with this structure and it has to do with unwanted writeconflicts. Although a take and put can be executed concurrently because there is a seperate tail and head to place items on, one of the transactions is going to fail because of a write conflict on the size field, or on the head/tail because of the object granularity of the stm. This is an issue that is going to be solved in the future, but for the moment this structure will not be very concurrent. This even gets worse with longer transactions that are typical for stm's, compared to classic concurrency (the synchronized block could be seen as a transaction).

Author:: Peter Veentjer.

Nested Class Summary
`class`	`TransactionalLinkedList.DescendingIteratorImpl`
`class`	`TransactionalLinkedList.IteratorImpl`
`class`	`TransactionalLinkedList.ListIteratorImpl`
`static class`	`TransactionalLinkedList.Node<E>`

Constructor Summary
`TransactionalLinkedList()`
`TransactionalLinkedList(int maxCapacity)`

Method Summary
`void`	`add(int index, E element)`
`boolean`	`addAll(int index, java.util.Collection<? extends E> c)`
`void`	`clear()`
`java.util.Iterator<E>`	`descendingIterator()`
`protected void`	`doAddFirst(E e)`
`protected void`	`doAddLast(E e)`
`protected E`	`doRemoveFirst()`
`protected E`	`doRemoveLast()`
`boolean`	`equals(java.lang.Object thatObj)`
`E`	`get(int index)`
`int`	`getMaxCapacity()`
`int`	`hashCode()`
`int`	`indexOf(java.lang.Object o)`
`java.util.Iterator<E>`	`iterator()`
`int`	`lastIndexOf(java.lang.Object o)`
`java.util.ListIterator<E>`	`listIterator()`
`java.util.ListIterator<E>`	`listIterator(int index)`
`E`	`peekFirst()`
`E`	`peekLast()`
`int`	`remainingCapacity()`
`E`	`remove(int index)`
`boolean`	`remove(java.lang.Object item)`
`E`	`set(int index, E element)`
`int`	`size()`
`java.util.List<E>`	`subList(int fromIndex, int toIndex)`

Methods inherited from class org.multiverse.transactional.collections.AbstractBlockingDeque
`add, addAll, addFirst, addLast, drainTo, drainTo, element, getFirst, getLast, hasNoStorageCapacity, offer, offer, offerFirst, offerFirst, offerLast, offerLast, peek, poll, poll, pollFirst, pollFirst, pollLast, pollLast, pop, push, put, putFirst, putLast, remove, removeFirst, removeFirstOccurrence, removeLast, removeLastOccurrence, take, takeFirst, takeLast, takeUninterruptible`

Methods inherited from class java.util.AbstractCollection
`contains, containsAll, isEmpty, removeAll, retainAll, toArray, toArray, toString`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface java.util.List
`add, addAll, contains, containsAll, isEmpty, removeAll, retainAll, toArray, toArray`

Methods inherited from interface java.util.concurrent.BlockingDeque
`contains`

Constructor Detail