Java的多线程编程模型3 -- 在1.5之前怎么并发

在java1.5之前，java在并发上面的建树不多，只提供了为数不多的方式来提供提高并发的效率。

其中synchronized关键字是使用最多的，这个看似简单的锁方式，效率奇差，所以那会，java程序员对于c++程序员的在java并发上的诟病总是无力回击。

在1.5之前，java提供的并发容器Vector，我们来看下具体的实现java.util.Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public synchronized void copyInto(Object[] anArray) {
	System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }
    public synchronized void trimToSize() {
	modCount++;
	int oldCapacity = elementData.length;
	if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
	}
    }
    public synchronized void ensureCapacity(int minCapacity) {
	modCount++;
	ensureCapacityHelper(minCapacity);
    }
... ...
}

从中可以看出，Vector是把所有的方法前面的加上了synchronized关键字

在来看另外的一类静态方法，这类容器可以把List在包装一层，让后就可以作为并发的容器

       List list = Collections.synchronizedList(new ArrayList());
           ...
       synchronized(list) {
           Iterator i = list.iterator(); // Must be in synchronized block
           while (i.hasNext())
               foo(i.next());
       }

仔细分析会发现

    public static <T> List<T> synchronizedList(List<T> list) {
	return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<T>(list) :
                new SynchronizedList<T>(list));
    }

原来Collections.synchronizedList(List<T> list))这个方法最终会新建一个SynchronizedList<E>，它是继承自SynchronizedCollection<E>，来看SynchronizedList<E>的构造函数，

	SynchronizedList(List<E> list) {
	    super(list);
	    this.list = list;
	}

看看父类的详细的构成

   static class SynchronizedCollection<E> implements Collection<E>, Serializable {
	// use serialVersionUID from JDK 1.2.2 for interoperability
	private static final long serialVersionUID = 3053995032091335093L;
	final Collection<E> c;  // Backing Collection
	final Object mutex;     // Object on which to synchronize
	SynchronizedCollection(Collection<E> c) {
            if (c==null)
                throw new NullPointerException();
	    this.c = c;
            mutex = this;
        }
	SynchronizedCollection(Collection<E> c, Object mutex) {
	    this.c = c;
            this.mutex = mutex;
        }
	public int size() {
	    synchronized(mutex) {return c.size();}
        }
	public boolean isEmpty() {
	    synchronized(mutex) {return c.isEmpty();}
        }
	public boolean contains(Object o) {
	    synchronized(mutex) {return c.contains(o);}
        }
	public Object[] toArray() {
	    synchronized(mutex) {return c.toArray();}
        }
	public <T> T[] toArray(T[] a) {
	    synchronized(mutex) {return c.toArray(a);}
        }
... ...
}

怎样，是不是有一种恍然大悟的感觉，原来在构造函数里面弄了一个 Object mutx = this,让后所有的方法在调用的时候都synchronized(mutex)

相同的方法有

public static <T> Collection<T> synchronizedCollection(Collection<T> c)

public static <T> List<T> synchronizedList(List<T> list)

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

public static <T> Set<T> synchronizedSet(Set<T> s)

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)