Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright (C) 2007 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  
  
  import java.util.List;
  import java.util.Map;
  import java.util.Queue;
  import java.util.Set;
  
Synchronized collection views. The returned synchronized collection views are serializable if the backing collection and the mutex are serializable.

If null is passed as the mutex parameter to any of this class's top-level methods or inner class constructors, the created object uses itself as the synchronization mutex.

This class should be used by other collection classes only.

Author(s):
Mike Bostock
Jared Levy
  
  @GwtCompatible(emulated = true)
  final class Synchronized {
    private Synchronized() {}
  
    static class SynchronizedObject implements Serializable {
      final Object delegate;
      final Object mutex;
  
      SynchronizedObject(Object delegate, @Nullable Object mutex) {
        this. = checkNotNull(delegate);
        this. = (mutex == null) ? this : mutex;
      }
  
      Object delegate() {
        return ;
      }
  
      // No equals and hashCode; see ForwardingObject for details.
  
      @Override public String toString() {
        synchronized () {
          return .toString();
        }
      }
  
      // Serialization invokes writeObject only when it's private.
      // The SynchronizedObject subclasses don't need a writeObject method since
      // they don't contain any non-transient member variables, while the
      // following writeObject() handles the SynchronizedObject members.
    }
  
    private static <E> Collection<E> collection(
        Collection<E> collection, @Nullable Object mutex) {
      return new SynchronizedCollection<E>(collectionmutex);
    }
  
    @VisibleForTesting static class SynchronizedCollection<E>
        extends SynchronizedObject implements Collection<E> {
      private SynchronizedCollection(
          Collection<E> delegate, @Nullable Object mutex) {
        super(delegatemutex);
      }
  
      @SuppressWarnings("unchecked")
      @Override Collection<E> delegate() {
        return (Collection<E>) super.delegate();
      }
 
     @Override
     public boolean add(E e) {
       synchronized () {
         return delegate().add(e);
       }
     }
 
     @Override
     public boolean addAll(Collection<? extends E> c) {
       synchronized () {
         return delegate().addAll(c);
       }
     }
 
     @Override
     public void clear() {
       synchronized () {
         delegate().clear();
       }
     }
 
     @Override
     public boolean contains(Object o) {
       synchronized () {
         return delegate().contains(o);
       }
     }
 
     @Override
     public boolean containsAll(Collection<?> c) {
       synchronized () {
         return delegate().containsAll(c);
       }
     }
 
     @Override
     public boolean isEmpty() {
       synchronized () {
         return delegate().isEmpty();
       }
     }
 
     @Override
     public Iterator<E> iterator() {
       return delegate().iterator(); // manually synchronized
     }
 
     @Override
     public boolean remove(Object o) {
       synchronized () {
         return delegate().remove(o);
       }
     }
 
     @Override
     public boolean removeAll(Collection<?> c) {
       synchronized () {
         return delegate().removeAll(c);
       }
     }
 
     @Override
     public boolean retainAll(Collection<?> c) {
       synchronized () {
         return delegate().retainAll(c);
       }
     }
 
     @Override
     public int size() {
       synchronized () {
         return delegate().size();
       }
     }
 
     @Override
     public Object[] toArray() {
       synchronized () {
         return delegate().toArray();
       }
     }
 
     @Override
     public <T> T[] toArray(T[] a) {
       synchronized () {
         return delegate().toArray(a);
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   @VisibleForTesting static <E> Set<E> set(Set<E> set, @Nullable Object mutex) {
     return new SynchronizedSet<E>(setmutex);
   }
 
   static class SynchronizedSet<E>
       extends SynchronizedCollection<E> implements Set<E> {
 
     SynchronizedSet(Set<E> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @Override Set<E> delegate() {
       return (Set<E>) super.delegate();
     }
 
     @Override public boolean equals(Object o) {
       if (o == this) {
         return true;
       }
       synchronized () {
         return delegate().equals(o);
       }
     }
 
     @Override public int hashCode() {
       synchronized () {
         return delegate().hashCode();
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   private static <E> SortedSet<E> sortedSet(
       SortedSet<E> set, @Nullable Object mutex) {
     return new SynchronizedSortedSet<E>(setmutex);
   }
 
   static class SynchronizedSortedSet<E> extends SynchronizedSet<E>
       implements SortedSet<E> {
     SynchronizedSortedSet(SortedSet<E> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @Override SortedSet<E> delegate() {
       return (SortedSet<E>) super.delegate();
     }
 
     @Override
     public Comparator<? super E> comparator() {
       synchronized () {
         return delegate().comparator();
       }
     }
 
     @Override
     public SortedSet<E> subSet(E fromElement, E toElement) {
       synchronized () {
         return sortedSet(delegate().subSet(fromElementtoElement), );
       }
     }
 
     @Override
     public SortedSet<E> headSet(E toElement) {
       synchronized () {
         return sortedSet(delegate().headSet(toElement), );
       }
     }
 
     @Override
     public SortedSet<E> tailSet(E fromElement) {
       synchronized () {
         return sortedSet(delegate().tailSet(fromElement), );
       }
     }
 
     @Override
     public E first() {
       synchronized () {
         return delegate().first();
       }
     }
 
     @Override
     public E last() {
       synchronized () {
         return delegate().last();
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   private static <E> List<E> list(List<E> list, @Nullable Object mutex) {
     return (list instanceof RandomAccess)
         ? new SynchronizedRandomAccessList<E>(listmutex)
         : new SynchronizedList<E>(listmutex);
   }
 
   private static class SynchronizedList<E> extends SynchronizedCollection<E>
       implements List<E> {
     SynchronizedList(List<E> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @Override List<E> delegate() {
       return (List<E>) super.delegate();
     }
 
     @Override
     public void add(int index, E element) {
       synchronized () {
         delegate().add(indexelement);
       }
     }
 
     @Override
     public boolean addAll(int indexCollection<? extends E> c) {
       synchronized () {
         return delegate().addAll(indexc);
       }
     }
 
     @Override
     public E get(int index) {
       synchronized () {
         return delegate().get(index);
       }
     }
 
     @Override
     public int indexOf(Object o) {
       synchronized () {
         return delegate().indexOf(o);
       }
     }
 
     @Override
     public int lastIndexOf(Object o) {
       synchronized () {
         return delegate().lastIndexOf(o);
       }
     }
 
     @Override
     public ListIterator<E> listIterator() {
       return delegate().listIterator(); // manually synchronized
     }
 
     @Override
     public ListIterator<E> listIterator(int index) {
       return delegate().listIterator(index); // manually synchronized
     }
 
     @Override
     public E remove(int index) {
       synchronized () {
         return delegate().remove(index);
       }
     }
 
     @Override
     public E set(int index, E element) {
       synchronized () {
         return delegate().set(indexelement);
       }
     }
 
     @Override
     public List<E> subList(int fromIndexint toIndex) {
       synchronized () {
         return list(delegate().subList(fromIndextoIndex), );
       }
     }
 
     @Override public boolean equals(Object o) {
       if (o == this) {
         return true;
       }
       synchronized () {
         return delegate().equals(o);
       }
     }
 
     @Override public int hashCode() {
       synchronized () {
         return delegate().hashCode();
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   private static class SynchronizedRandomAccessList<E>
       extends SynchronizedList<E> implements RandomAccess {
     SynchronizedRandomAccessList(List<E> list, @Nullable Object mutex) {
       super(listmutex);
     }
     private static final long serialVersionUID = 0;
   }
 
   static <E> Multiset<E> multiset(
       Multiset<E> multiset, @Nullable Object mutex) {
     if (multiset instanceof SynchronizedMultiset ||
         multiset instanceof ImmutableMultiset) {
       return multiset;
     }
     return new SynchronizedMultiset<E>(multisetmutex);
   }
 
   private static class SynchronizedMultiset<E> extends SynchronizedCollection<E>
       implements Multiset<E> {
     transient Set<E> elementSet;
     transient Set<Entry<E>> entrySet;
 
     SynchronizedMultiset(Multiset<E> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @Override Multiset<E> delegate() {
       return (Multiset<E>) super.delegate();
     }
 
     @Override
     public int count(Object o) {
       synchronized () {
         return delegate().count(o);
       }
     }
 
     @Override
     public int add(E eint n) {
       synchronized () {
         return delegate().add(en);
       }
     }
 
     @Override
     public int remove(Object oint n) {
       synchronized () {
         return delegate().remove(on);
       }
     }
 
     @Override
     public int setCount(E elementint count) {
       synchronized () {
         return delegate().setCount(elementcount);
       }
     }
 
     @Override
     public boolean setCount(E elementint oldCountint newCount) {
       synchronized () {
         return delegate().setCount(elementoldCountnewCount);
       }
     }
 
     @Override
     public Set<E> elementSet() {
       synchronized () {
         if ( == null) {
            = typePreservingSet(delegate().elementSet(), );
         }
         return ;
       }
     }
 
     @Override
     public Set<Entry<E>> entrySet() {
       synchronized () {
         if ( == null) {
            = typePreservingSet(delegate().entrySet(), );
         }
         return ;
       }
     }
 
     @Override public boolean equals(Object o) {
       if (o == this) {
         return true;
       }
       synchronized () {
         return delegate().equals(o);
       }
     }
 
     @Override public int hashCode() {
       synchronized () {
         return delegate().hashCode();
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   static <K, V> Multimap<K, V> multimap(
       Multimap<K, V> multimap, @Nullable Object mutex) {
     if (multimap instanceof SynchronizedMultimap ||
         multimap instanceof ImmutableMultimap) {
       return multimap;
     }
     return new SynchronizedMultimap<K, V>(multimapmutex);
   }
 
   private static class SynchronizedMultimap<K, V> extends SynchronizedObject
       implements Multimap<K, V> {
     transient Set<K> keySet;
     transient Collection<V> valuesCollection;
     transient Collection<Map.Entry<K, V>> entries;
     transient Map<K, Collection<V>> asMap;
     transient Multiset<K> keys;
 
     @SuppressWarnings("unchecked")
     @Override Multimap<K, V> delegate() {
       return (Multimap<K, V>) super.delegate();
     }
 
     SynchronizedMultimap(Multimap<K, V> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @Override
     public int size() {
       synchronized () {
         return delegate().size();
       }
     }
 
     @Override
     public boolean isEmpty() {
       synchronized () {
         return delegate().isEmpty();
       }
     }
 
     @Override
     public boolean containsKey(Object key) {
       synchronized () {
         return delegate().containsKey(key);
       }
     }
 
     @Override
     public boolean containsValue(Object value) {
       synchronized () {
         return delegate().containsValue(value);
       }
     }
 
     @Override
     public boolean containsEntry(Object keyObject value) {
       synchronized () {
         return delegate().containsEntry(keyvalue);
       }
     }
 
     @Override
     public Collection<V> get(K key) {
       synchronized () {
         return typePreservingCollection(delegate().get(key), );
       }
     }
 
     @Override
     public boolean put(K key, V value) {
       synchronized () {
         return delegate().put(keyvalue);
       }
     }
 
     @Override
     public boolean putAll(K keyIterable<? extends V> values) {
       synchronized () {
         return delegate().putAll(keyvalues);
       }
     }
 
     @Override
     public boolean putAll(Multimap<? extends K, ? extends V> multimap) {
       synchronized () {
         return delegate().putAll(multimap);
       }
     }
 
     @Override
     public Collection<V> replaceValues(K keyIterable<? extends V> values) {
       synchronized () {
         return delegate().replaceValues(keyvalues); // copy not synchronized
       }
     }
 
     @Override
     public boolean remove(Object keyObject value) {
       synchronized () {
         return delegate().remove(keyvalue);
       }
     }
 
     @Override
     public Collection<V> removeAll(Object key) {
       synchronized () {
         return delegate().removeAll(key); // copy not synchronized
       }
     }
 
     @Override
     public void clear() {
       synchronized () {
         delegate().clear();
       }
     }
 
     @Override
     public Set<K> keySet() {
       synchronized () {
         if ( == null) {
            = typePreservingSet(delegate().keySet(), );
         }
         return ;
       }
     }
 
     @Override
     public Collection<V> values() {
       synchronized () {
         if ( == null) {
            = collection(delegate().values(), );
         }
         return ;
       }
     }
 
     @Override
     public Collection<Map.Entry<K, V>> entries() {
       synchronized () {
         if ( == null) {
            = typePreservingCollection(delegate().entries(), );
         }
         return ;
       }
     }
 
     @Override
     public Map<K, Collection<V>> asMap() {
       synchronized () {
         if ( == null) {
            = new SynchronizedAsMap<K, V>(delegate().asMap(), );
         }
         return ;
       }
     }
 
     @Override
     public Multiset<K> keys() {
       synchronized () {
         if ( == null) {
            = multiset(delegate().keys(), );
         }
         return ;
       }
     }
 
     @Override public boolean equals(Object o) {
       if (o == this) {
         return true;
       }
       synchronized () {
         return delegate().equals(o);
       }
     }
 
     @Override public int hashCode() {
       synchronized () {
         return delegate().hashCode();
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   static <K, V> ListMultimap<K, V> listMultimap(
       ListMultimap<K, V> multimap, @Nullable Object mutex) {
     if (multimap instanceof SynchronizedListMultimap ||
         multimap instanceof ImmutableListMultimap) {
       return multimap;
     }
     return new SynchronizedListMultimap<K, V>(multimapmutex);
   }
 
   private static class SynchronizedListMultimap<K, V>
       extends SynchronizedMultimap<K, V> implements ListMultimap<K, V> {
         ListMultimap<K, V> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
     @Override ListMultimap<K, V> delegate() {
       return (ListMultimap<K, V>) super.delegate();
     }
     @Override public List<V> get(K key) {
       synchronized () {
         return list(delegate().get(key), );
       }
     }
     @Override public List<V> removeAll(Object key) {
       synchronized () {
         return delegate().removeAll(key); // copy not synchronized
       }
     }
     @Override public List<V> replaceValues(
         K keyIterable<? extends V> values) {
       synchronized () {
         return delegate().replaceValues(keyvalues); // copy not synchronized
       }
     }
     private static final long serialVersionUID = 0;
   }
 
   static <K, V> SetMultimap<K, V> setMultimap(
       SetMultimap<K, V> multimap, @Nullable Object mutex) {
     if (multimap instanceof SynchronizedSetMultimap ||
         multimap instanceof ImmutableSetMultimap) {
       return multimap;
     }
     return new SynchronizedSetMultimap<K, V>(multimapmutex);
   }
 
   private static class SynchronizedSetMultimap<K, V>
       extends SynchronizedMultimap<K, V> implements SetMultimap<K, V> {
     transient Set<Map.Entry<K, V>> entrySet;
 
         SetMultimap<K, V> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
     @Override SetMultimap<K, V> delegate() {
       return (SetMultimap<K, V>) super.delegate();
     }
     @Override public Set<V> get(K key) {
       synchronized () {
         return set(delegate().get(key), );
       }
     }
     @Override public Set<V> removeAll(Object key) {
       synchronized () {
         return delegate().removeAll(key); // copy not synchronized
       }
     }
     @Override public Set<V> replaceValues(
         K keyIterable<? extends V> values) {
       synchronized () {
         return delegate().replaceValues(keyvalues); // copy not synchronized
       }
     }
     @Override public Set<Map.Entry<K, V>> entries() {
       synchronized () {
         if ( == null) {
            = set(delegate().entries(), );
         }
         return ;
       }
     }
     private static final long serialVersionUID = 0;
   }
 
   static <K, V> SortedSetMultimap<K, V> sortedSetMultimap(
       SortedSetMultimap<K, V> multimap, @Nullable Object mutex) {
     if (multimap instanceof SynchronizedSortedSetMultimap) {
       return multimap;
     }
     return new SynchronizedSortedSetMultimap<K, V>(multimapmutex);
   }
 
   private static class SynchronizedSortedSetMultimap<K, V>
       extends SynchronizedSetMultimap<K, V> implements SortedSetMultimap<K, V> {
         SortedSetMultimap<K, V> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
     @Override SortedSetMultimap<K, V> delegate() {
       return (SortedSetMultimap<K, V>) super.delegate();
     }
     @Override public SortedSet<V> get(K key) {
       synchronized () {
         return sortedSet(delegate().get(key), );
       }
     }
     @Override public SortedSet<V> removeAll(Object key) {
       synchronized () {
         return delegate().removeAll(key); // copy not synchronized
       }
     }
     @Override public SortedSet<V> replaceValues(
         K keyIterable<? extends V> values) {
       synchronized () {
         return delegate().replaceValues(keyvalues); // copy not synchronized
       }
     }
     @Override
     public Comparator<? super V> valueComparator() {
       synchronized () {
         return delegate().valueComparator();
       }
     }
     private static final long serialVersionUID = 0;
   }
 
   private static <E> Collection<E> typePreservingCollection(
       Collection<E> collection, @Nullable Object mutex) {
     if (collection instanceof SortedSet) {
       return sortedSet((SortedSet<E>) collectionmutex);
     }
     if (collection instanceof Set) {
       return set((Set<E>) collectionmutex);
     }
     if (collection instanceof List) {
       return list((List<E>) collectionmutex);
     }
     return collection(collectionmutex);
   }
 
   private static <E> Set<E> typePreservingSet(
       Set<E> set, @Nullable Object mutex) {
     if (set instanceof SortedSet) {
       return sortedSet((SortedSet<E>) setmutex);
     } else {
       return set(setmutex);
     }
   }
 
   private static class SynchronizedAsMapEntries<K, V>
       extends SynchronizedSet<Map.Entry<K, Collection<V>>> {
         Set<Map.Entry<K, Collection<V>>> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @Override public Iterator<Map.Entry<K, Collection<V>>> iterator() {
       // Must be manually synchronized.
       final Iterator<Map.Entry<K, Collection<V>>> iterator = super.iterator();
       return new ForwardingIterator<Map.Entry<K, Collection<V>>>() {
         @Override protected Iterator<Map.Entry<K, Collection<V>>> delegate() {
           return iterator;
         }
 
         @Override public Map.Entry<K, Collection<V>> next() {
           final Map.Entry<K, Collection<V>> entry = super.next();
           return new ForwardingMapEntry<K, Collection<V>>() {
             @Override protected Map.Entry<K, Collection<V>> delegate() {
               return entry;
             }
             @Override public Collection<V> getValue() {
               return typePreservingCollection(entry.getValue(), );
             }
           };
         }
       };
     }
 
     // See Collections.CheckedMap.CheckedEntrySet for details on attacks.
 
     @Override public Object[] toArray() {
       synchronized () {
         return ObjectArrays.toArrayImpl(delegate());
       }
     }
     @Override public <T> T[] toArray(T[] array) {
       synchronized () {
         return ObjectArrays.toArrayImpl(delegate(), array);
       }
     }
     @Override public boolean contains(Object o) {
       synchronized () {
         return Maps.containsEntryImpl(delegate(), o);
       }
     }
     @Override public boolean containsAll(Collection<?> c) {
       synchronized () {
         return Collections2.containsAllImpl(delegate(), c);
       }
     }
     @Override public boolean equals(Object o) {
       if (o == this) {
         return true;
       }
       synchronized () {
         return Sets.equalsImpl(delegate(), o);
       }
     }
     @Override public boolean remove(Object o) {
       synchronized () {
         return Maps.removeEntryImpl(delegate(), o);
       }
     }
     @Override public boolean removeAll(Collection<?> c) {
       synchronized () {
         return Iterators.removeAll(delegate().iterator(), c);
       }
     }
     @Override public boolean retainAll(Collection<?> c) {
       synchronized () {
         return Iterators.retainAll(delegate().iterator(), c);
       }
     }
 
     private static final long serialVersionUID = 0;
   }
 
   static <K, V> Map<K, V> map(Map<K, V> map, @Nullable Object mutex) {
     return new SynchronizedMap<K, V>(mapmutex);
   }
 
   private static class SynchronizedMap<K, V> extends SynchronizedObject
       implements Map<K, V> {
     transient Set<K> keySet;
     transient Collection<V> values;
     transient Set<Map.Entry<K, V>> entrySet;
 
     SynchronizedMap(Map<K, V> delegate, @Nullable Object mutex) {
       super(delegatemutex);
     }
 
     @SuppressWarnings("unchecked")
     @Override Map<K, V> delegate() {
       return (Map<K, V>) super.delegate();
     }
 
     @Override
     public void clear() {
       synchronized () {
         delegate().clear();
       }
     }
 
     @Override
     public boolean containsKey(Object key) {
       synchronized () {
         return delegate().containsKey(key);
       }
     }
 
     @Override
     public boolean containsValue(Object value) {
       synchronized () {
         return delegate().containsValue(value);
       }
     }
 
     @Override
     public Set<Map.Entry<K, V>> entrySet() {
       synchronized () {
         if ( == null) {
            = set(delegate().entrySet(), );
         }
         return ;
       }
     }
 
     @Override
     public V get(Object key) {
       synchronized () {
         return delegate().get(key);
       }
     }
 
     @Override
     public boolean isEmpty() {
       synchronized () {
         return delegate().isEmpty();
       }
     }
 
     @Override
     public Set<K> keySet() {
       synchronized () {
         if ( == null) {
            = set(delegate().keySet(), );
         }
         return ;
       }
     }
 
     @Override
     public V put(K key, V value) {
       synchronized () {
         return delegate().put(keyvalue);
       }
     }
 
     @Override
     public void putAll(Map<? extends K, ? extends V> map) {
       synchronized () {
         delegate().putAll(map);
       }
     }
 
     @Override
     public V remove(Object key) {
       synchronized () {
         return delegate().remove(key);
       }
     }
 
     @Override
     public int size() {
       synchronized () {
        return delegate().size();
      }
    }
    @Override
    public Collection<V> values() {
      synchronized () {
        if ( == null) {
           = collection(delegate().values(), );
        }
        return ;
      }
    }
    @Override public boolean equals(Object o) {
      if (o == this) {
        return true;
      }
      synchronized () {
        return delegate().equals(o);
      }
    }
    @Override public int hashCode() {
      synchronized () {
        return delegate().hashCode();
      }
    }
    private static final long serialVersionUID = 0;
  }
  static <K, V> SortedMap<K, V> sortedMap(
      SortedMap<K, V> sortedMap, @Nullable Object mutex) {
    return new SynchronizedSortedMap<K, V>(sortedMap