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)