org.apache.commons.collections.collection.SynchronizedCollection java code examples

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

public Collection makeCollection() {
  return SynchronizedCollection.decorate(new ArrayList());
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Factory method to create a synchronized collection.
 * 
 * @param coll  the collection to decorate, must not be null
 * @return a new synchronized collection
 * @throws IllegalArgumentException if collection is null
 */
public static Collection decorate(Collection coll) {
  return new SynchronizedCollection(coll);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

/**
 * Returns a synchronized collection backed by the given collection.
 * <p>
 * You must manually synchronize on the returned buffer's iterator to 
 * avoid non-deterministic behavior:
 *  
 * <pre>
 * Collection c = CollectionUtils.synchronizedCollection(myCollection);
 * synchronized (c) {
 *     Iterator i = c.iterator();
 *     while (i.hasNext()) {
 *         process (i.next());
 *     }
 * }
 * </pre>
 * 
 * This method uses the implementation in the decorators subpackage.
 * 
 * @param collection  the collection to synchronize, must not be null
 * @return a synchronized collection backed by the given collection
 * @throws IllegalArgumentException  if the collection is null
 */
public static Collection synchronizedCollection(Collection collection) {
  return SynchronizedCollection.decorate(collection);
}

Javadoc

Decorates another Collection to synchronize its behaviour for a multi-threaded environment.

Iterators must be manually synchronized:

 
synchronized (coll) { 
Iterator it = coll.iterator(); 
// do stuff with iterator 
}

This class is Serializable from Commons Collections 3.1.

Most used methods

decorate
Factory method to create a synchronized collection.
<init>
Constructor that wraps (not copies).

Popular in Java

Reading from database using SQL prepared statement
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
getExternalFilesDir (Context)
requestLocationUpdates (LocationManager)
Component (java.awt)
A component is an object having a graphical representation that can be displayed on the screen and t
BigDecimal (java.math)
An immutable arbitrary-precision signed decimal.A value is represented by an arbitrary-precision "un
MalformedURLException (java.net)
This exception is thrown when a program attempts to create an URL from an incorrect specification.
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
Timestamp (java.sql)
A Java representation of the SQL TIMESTAMP type. It provides the capability of representing the SQL
Join (org.hibernate.mapping)
Best IntelliJ plugins

How to useSynchronizedCollection in org.apache.commons.collections.collection

Best Java code snippets using org.apache.commons.collections.collection.SynchronizedCollection (Showing top 17 results out of 315)

How to use
SynchronizedCollection
in
org.apache.commons.collections.collection