实现Java线程安全

一个类如果想要满足线程安全的条件：

每个线程都能正常的执行原子操作，保证得到正确的结果
这个类的对象可以同时被多个线程安全的访问
在每个线程的原子操作都完成后，对象处于合理的状态

一般情况下不可变类总是线程安全的，因为他的对象的状态始终不会改变，任何线程只能读取他的状态，而不能改变他的状态，例如String类就是一个不可变类，因为String类在我们的代码中使用的实在是太多了，如果设计成可变类后果可想而知……对于那些可变类，如果想要保证它的们的线程安全，就要保证对于他们的原子操作进行同步。

我们常说StirngBuffer是线程安全的，StringBuilder是线程不安全的，为什么呢？因为在StringBuffer类中大量使用了同步，以下只是一小部分方法，方法都用synchronized关键字修饰，做到同步

实现Java线程安全

但是大量运用同步可能对性能造成影响，同步的意思好比大家一起排队做某件事，举个例子i，有十个人去吃饭，但是饭店的座位只有一个，只能一个一个吃，第一个人先吃，这样依次下去，那么第十个人要等到前面九个人都吃完了才能吃饭，想想是不是很委屈。对可变类实现同步往往都会降低并发性能，为了减少带来的影响，我们可以采取下面的措施：

只对额能导致资源竞争的代码进行同步处理，对于那些没有资源竞争的代码不进行处理，例如我们在对一个属性提供set和get方法的时候，试着只提供get方法获取值，不提供set方法修改值，这样虽然好多个线程同时访问，也不会造成数据的错误和资源的竞争。
对于多线程环境下我们提供一个运行方式，对于单线程环境下提供一个运行方式。一个类提供两种实现方式，在单线程运行环境下采用微进行同步实现的代码，对于对线程运行环境下采用进行同步处理的代码，避免一刀切。这里有个很好的例子，Map，Set，List这三个集合类都是线程不安全的，在多线程环境下怎么办呢？Collections类提供了很好的解决办法，他提供了返回这些集合同步版本的静态内部类，并在类中重写了集合中所有有资源竞争的方法，加了synchronized关键字进行同步处理

实现Java线程安全

SynchronizedCollection和三个集合一样，也是实现了同步的方法，看代码：

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

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

/**
 * @serial include
 */
static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> {
    private static final long serialVersionUID = -7754090372962971524L;

    final List<E> list;

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

    public boolean equals(Object o) {
        if (this == o)
            return true;
        synchronized (mutex) {return list.equals(o);}
    }
    public int hashCode() {
        synchronized (mutex) {return list.hashCode();}
    }

    public E get(int index) {
        synchronized (mutex) {return list.get(index);}
    }
    public E set(int index, E element) {
        synchronized (mutex) {return list.set(index, element);}
    }
    public void add(int index, E element) {
        synchronized (mutex) {list.add(index, element);}
    }
    public E remove(int index) {
        synchronized (mutex) {return list.remove(index);}
    }

    public int indexOf(Object o) {
        synchronized (mutex) {return list.indexOf(o);}
    }
    public int lastIndexOf(Object o) {
        synchronized (mutex) {return list.lastIndexOf(o);}
    }

    public boolean addAll(int index, Collection<? extends E> c) {
        synchronized (mutex) {return list.addAll(index, c);}
    }

    public ListIterator<E> listIterator() {
        return list.listIterator(); // Must be manually synched by user
    }

    public ListIterator<E> listIterator(int index) {
        return list.listIterator(index); // Must be manually synched by user
    }

    public List<E> subList(int fromIndex, int toIndex) {
        synchronized (mutex) {
            return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                        mutex);
        }
    }

public static <T> Set<T> synchronizedSet(Set<T> s) {
    return new SynchronizedSet<>(s);
}

static <T> Set<T> synchronizedSet(Set<T> s, Object mutex) {
    return new SynchronizedSet<>(s, mutex);
}

/**
 * @serial include
 */
static class SynchronizedSet<E>
      extends SynchronizedCollection<E>
      implements Set<E> {
    private static final long serialVersionUID = 487447009682186044L;

    SynchronizedSet(Set<E> s) {
        super(s);
    }
    SynchronizedSet(Set<E> s, Object mutex) {
        super(s, mutex);
    }

    public boolean equals(Object o) {
        if (this == o)
            return true;
        synchronized (mutex) {return c.equals(o);}
    }
    public int hashCode() {
        synchronized (mutex) {return c.hashCode();}
    }
}

我们可以通过代码看到他是实现了一个静态方法，在静态方法中去创建这个静态类，而这个静态类重写了集合中有资源竞争关系的方法（加了同步处理）

参考：Java面向对象编程--孙卫琴

实现Java线程安全

相关推荐