理解synchronized

理解synchronized

再从下面几个角度来进一步理解一下synchronized：

·        可重入性

·        内存可见性

·        死锁

 

可重入性

synchronized有一个重要的特征，它是可重入的，也就是说，对同一个执行线程，它在获得了锁之后，在调用其他需要同样锁的代码时，可以直接调用，比如说，在一个synchronized实例方法内，可以直接调用其他synchronized实例方法。可重入是一个非常自然的属性，应该是很容易理解的，之所以强调，是因为并不是所有锁都是可重入的。

 

可重入是通过记录锁的持有线程和持有数量来实现的，当调用被synchronized保护的代码时，检查对象是否已被锁，如果是，再检查是否被当前线程锁定，如果是，增加持有数量，如果不是被当前线程锁定，才加入等待队列，当释放锁时，减少持有数量，当数量变为0时才释放整个锁。

 

内存可见性

对于复杂一些的操作，synchronized可以实现原子操作，避免出现竞态条件，但对于明显的本来就是原子的操作方法，也需要加synchronized吗？比如说，对于下面的开关类Switcher，它只有一个boolean变量on和对应的setter/getter方法：

publicclass Switcher {    private boolean on;    public boolean isOn() {        return on;    }    public void setOn(boolean on) {        this.on = on;    }} 

当多线程同时访问同一个Switcher对象时，会有问题吗？没有竞态条件问题，但正如上节所说，有内存可见性问题，而加上synchronized可以解决这个问题。

 

synchronized除了保证原子操作外，它还有一个重要的作用，就是保证内存可见性，在释放锁时，所有写入都会写回内存，而获得锁后，都会从内存中读最新数据。

 

不过，如果只是为了保证内存可见性，使用synchronzied的成本有点高，有一个更轻量级的方式，那就是给变量加修饰符volatile，如下所示：

publicclass Switcher {    private volatile boolean on;    public boolean isOn() {        return on;    }    public void setOn(boolean on) {        this.on = on;    }}

 

加了volatile之后，Java会在操作对应变量时插入特殊的指令，保证读写到内存最新值，而非缓存的值。

 

死锁

使用synchronized或者其他锁，要注意死锁，所谓死锁就是类似这种现象，比如，有a, b两个线程，a持有锁A，在等待锁B，而b持有锁B，在等待锁A，a,b陷入了互相等待，最后谁都执行不下去。示例代码如下所示：

publicclass DeadLockDemo {    private static Object lockA = new Object();    private static Object lockB = new Object();    private static void startThreadA() {        Thread aThread = new Thread() {            @Override            public void run() {                synchronized (lockA) {                   try {                       Thread.sleep(1000);                   } catch (InterruptedException e) {                   }                   synchronized (lockB) {                   }                }            }        };        aThread.start();    }    private static void startThreadB() {        Thread bThread = new Thread() {            @Override            public void run() {                synchronized (lockB) {                   try {                       Thread.sleep(1000);                   } catch (InterruptedException e) {                   }                   synchronized (lockA) {                   }                }            }        };        bThread.start();    }    public static void main(String[] args) {        startThreadA();        startThreadB();    }}

 

运行后aThread和bThread陷入了相互等待。怎么解决呢？首先，应该尽量避免在持有一个锁的同时去申请另一个锁，如果确实需要多个锁，所有代码都应该按照相同的顺序去申请锁，比如，对于上面的例子，可以约定都先申请lockA，再申请lockB。

 

不过，在复杂的项目代码中，这种约定可能难以做到。还有一种方法是使用后续章节介绍的显式锁接口Lock，它支持尝试获取锁(tryLock)和带时间限制的获取锁方法，使用这些方法可以在获取不到锁的时候释放已经持有的锁，然后再次尝试获取锁或干脆放弃，以避免死锁。

 

如果还是出现了死锁，怎么办呢？Java不会主动处理，不过，借助一些工具，我们可以发现运行中的死锁，比如，Java自带的jstack命令会报告发现的死锁，对于上面的程序，在我的电脑上，jstack会有如下报告：

同步容器及其注意事项

同步容器

Collection的一些方法，它们可以返回线程安全的同步容器，比如：

publicstatic <T> Collection<T> synchronizedCollection(Collection<T>c)publicstatic <T> List<T> synchronizedList(List<T> list) public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)它们是给所有容器方法都加上synchronized来实现安全的，比如SynchronizedCollection，其部分代码如下所示：staticclass SynchronizedCollection<E> implements Collection<E> {    final Collection<E> c;  // Backing Collection    final Object mutex;     // Object onwhich to synchronize    SynchronizedCollection(Collection<E> c) {        if (c==null)            throw newNullPointerException();        this.c = c;        mutex = this;    }    public int size() {        synchronized (mutex) {return c.size();}    }    public boolean add(E e) {        synchronized (mutex) {return c.add(e);}    }    public boolean remove(Object o) {        synchronized (mutex) {return c.remove(o);}    }    //....}

 

这里线程安全针对的是容器对象，指的是当多个线程并发访问同一个容器对象时，不需要额外的同步操作，也不会出现错误的结果。

 

加了synchronized，所有方法调用变成了原子操作，客户端在调用时，是不是就绝对安全了呢？不是的，至少有以下情况需要注意：

·        复合操作，比如先检查再更新

·        伪同步

·        迭代

复合操作

先来看复合操作，我们看段代码：

publicclass EnhancedMap <K, V> {    Map<K, V> map;        public EnhancedMap(Map<K,V> map){        this.map =Collections.synchronizedMap(map);    }        public V putIfAbsent(K key, V value){         V old = map.get(key);         if(old!=null){             return old;         }         map.put(key, value);         return null;     }        public void put(K key, V value){        map.put(key, value);    }        //... 其他代码}

 

EnhancedMap是一个装饰类，接受一个Map对象，调用synchronizedMap转换为了同步容器对象map，增加了一个方法putIfAbsent，该方法只有在原Map中没有对应键的时候才添加。

 

map的每个方法都是安全的，但这个复合方法putIfAbsent是安全的吗？显然是否定的，这是一个检查然后再更新的复合操作，在多线程的情况下，可能有多个线程都执行完了检查这一步，都发现Map中没有对应的键，然后就会都调用put，而这就破坏了putIfAbsent方法期望保持的语义。

 

伪同步

那给该方法加上synchronized就能实现安全吗？如下所示：

public synchronized V putIfAbsent(K key, V value){    V old = map.get(key);    if(old!=null){        return old;    }    map.put(key, value);    return null;}

 

答案是否定的！为什么呢？同步错对象了。putIfAbsent同步使用的是EnhancedMap对象，而其他方法(如代码中的put方法)使用的是Collections.synchronizedMap返回的对象map，两者是不同的对象。要解决这个问题，所有方法必须使用相同的锁，可以使用EnhancedMap的对象锁，也可以使用map。使用EnhancedMap对象作为锁，则EnhancedMap中的所有方法都需要加上synchronized。使用map作为锁，putIfAbsent方法可以改为：

publicV putIfAbsent(K key, V value){    synchronized(map){        V old = map.get(key);         if(old!=null){             return old;         }         map.put(key, value);         return null;        }}

 

迭代

对于同步容器对象，虽然单个操作是安全的，但迭代并不是。我们看个例子，创建一个同步List对象，一个线程修改List，另一个遍历，看看会发生什么，代码为：

privatestatic void startModifyThread(final List<String> list) {    Thread modifyThread = new Thread(new Runnable() {        @Override        public void run() {            for (int i = 0; i <100; i++) {               list.add("item " + i);                try{                   Thread.sleep((int) (Math.random() * 10));                }catch (InterruptedException e) {                }            }        }    });    modifyThread.start();}private static void startIteratorThread(final List<String> list) {    Thread iteratorThread = new Thread(new Runnable() {        @Override        public void run() {            while (true) {                for(String str : list) {                }            }        }    });    iteratorThread.start();}public static void main(String[] args) {    final List<String> list = Collections            .synchronizedList(newArrayList<String>());    startIteratorThread(list);    startModifyThread(list);}

 

运行该程序，程序抛出并发修改异常：

Exceptionin thread "Thread-0" java.util.ConcurrentModificationException    atjava.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)    at java.util.ArrayList$Itr.next(ArrayList.java:831)

 

我们之前介绍过这个异常，如果在遍历的同时容器发生了结构性变化，就会抛出该异常，同步容器并没有解决这个问题，如果要避免这个异常，需要在遍历的时候给整个容器对象加锁，比如，上面的代码，startIteratorThread可以改为：

privatestatic void startIteratorThread(final List<String> list) {    Thread iteratorThread = new Thread(new Runnable() {        @Override        public void run() {            while (true) {                synchronized(list){                   for (String str : list) {                   }                    }            }        }    });    iteratorThread.start();}

 

并发容器

除了以上这些注意事项，同步容器的性能也是比较低的，当并发访问量比较大的时候性能很差。所幸的是，Java中还有很多专为并发设计的容器类，比如：

·        CopyOnWriteArrayList

·        ConcurrentHashMap

·        ConcurrentLinkedQueue

·        ConcurrentSkipListSet

 

这些容器类都是线程安全的，但都没有使用synchronized、没有迭代问题、直接支持一些复合操作、性能也高得多，

原文链接：http://mp.weixin.qq.com/s/cYmA7_9yMYf25zzKEYV4vA