java基础巩固之-Synchonized关键字

概述

上次说到的关于线程带来的竞态性和内存可见性两个问题，可以用Synchonized关键字来解决。

用法

synchonized可以用在修饰实例方法、静态方法以及代码块。

1、实例方法

public class Counter {
    private int count;

public synchronized void incr(){
    count ++;
}

public synchronized int getCount() {
    return count;
}
}

这样使用多个线程去调用里面的方法就不会存在问题了。但是需要注意的是synchronizied在这里面同步的是对象，也就是当前的this,也就是说如果这里有不同的对象，那他们是可以同时调用incr()方法的。 而且对于一个对象来说，里面的所有sychronized修饰的方法都要按照顺序执行。

2、静态方法

public class StaticCounter {
private static int count = 0;

public static synchronized void incr() {
    count++;
}

public static synchronized int getCount() {
    return count;
}
}

修饰静态方法的时候同步的是类的对象，也就是StaticCounter.class这个对象。所以如果一个类里面有实例的同步方法也有静态的同步方法，因为他们修饰的是不同对象所以可以被多线程同时调用。

3、代码快

public class Counter {
private int count;

public void incr(){
    synchronized(this){
        count ++;    
    }
}

public int getCount() {
    synchronized(this){
        return count;
    }
}
}

这个跟实例方法前面的sychonized效果是一样的，其实可以用任意对象来做同步锁，因为每个对象都会有一个锁和一个等待队列。

public class Counter {
private int count;
private Object lock = new Object();

public void incr(){
    synchronized(lock){
        count ++;    
    }
}

public int getCount() {
    synchronized(lock){
        return count;
    }
}
}

synchonized的特性

1、可重入性
当一个线程获得了锁以后，她可以调用需要同样锁的其它代码。

2、内存可见性
他可以把写入数据立马同步到内存，也可以保证从内存里面读到的都是最新数据。为了保证内存可见性还有一种比较轻量的方法就是给变量加上修饰符volatile，也可以保证内存可见性的问题。

3、死锁

public class 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();
}
}

这段代码就有死锁问题，所以一般避免在持有一个锁的同时去申请另一个锁，如果确实需要多个锁，所有代码应该按照相同的顺序去申请。

同步容器就能完全同步吗？

在下面几种情况下就不能保证完全同步

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

public class 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);
}
   }

在putIfAbsent方法中很可能多个线程都执行到old!=null这行代码，这样就有问题了。

2、伪同步

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

为了解决上面的问题，在方法上加入synchronized关键字，但是这样也并不能解决同步的问题，因为这里我们同步的对象是this，而封装的map里面，对象是map。所以我们需要让他们同步一个对象，要不把方法上都加上synchronized或者用map对象进行同步。

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

3、迭代
在修改集合的同时，遍历集合就会出现问题，但这个时候给集合加上synchronized方法就可以保证了。

总结

主要学习了synchronzied关键字的用法特性，以及他本质同步的是对象，这点很重要。然后也学习了关于同步容器中会出现的一些问题和解决方案。所以从根本上理解多线程造成的影响，以及解决多线程的方案能让我们掌握的更好。

注:学习资料及代码片段来自老马学编程。