并发带来的问题
先看一个单例类，后文中都会用到:
public class SimpleWorkingHardSingleton {
private static SimpleWorkingHardSingleton simpleSingleton = new SimpleWorkingHardSingleton();
// 数量
private int count;
private SimpleWorkingHardSingleton() {
count = 0;
}
public static SimpleWorkingHardSingleton getInstance() {
return simpleSingleton;
}
public int getCount() {
return count;
}
public void addCount(int increment) {
this.count += increment;
System.out.println(this.count);
}
}
使用原子变量同步
上文中，我们已经知道这个类的getCount方法对count的操作是线程不安全的，我们可以用一些原子变量来实现原子性：
public class SimpleWorkingHardSingleton {
private static SimpleWorkingHardSingleton simpleSingleton = new SimpleWorkingHardSingleton();
// 数量
private AtomicLong atomicCount = new AtomicLong(0);
private SimpleWorkingHardSingleton() {
count = 0;
}
public static SimpleWorkingHardSingleton getInstance() {
return simpleSingleton;
}
public AtomicLong getAtomicCount() {
return atomicCount;
}
public void addAtomicCount(long increment) {
this.atomicCount.getAndAdd(increment);
}
}
可以看到，在这个类中，我们把count使用AtomicLong原子类。java的jdk包实现了一系列的原子类，这些原子类型的操作都是原子的。那么count的增加就不会分为3步（获取，增加，赋值）了，这个原子的操作是原子类内部实现的，我们在使用过程中只需知道这个操作过程是原子的、不可分割的即可。在使用原子类型的情况下：count变量是会达到预期的效果的。
原子变量失效情况
这里所说的原子变量的失效情况是指当类中使用了多个原子变量，如果一个操作要改变多个原子变量，那么还是会出现同步问题：
public class SimpleWorkingHardSingleton {
private static SimpleWorkingHardSingleton simpleSingleton = new SimpleWorkingHardSingleton();
// 数量
private AtomicLong atomicCount = new AtomicLong(0);
private AtomicLong atomicCountCopy = new AtomicLong(0);
private SimpleWorkingHardSingleton() {
count = 0;
}
public static SimpleWorkingHardSingleton getInstance() {
return simpleSingleton;
}
public AtomicLong getAtomicCount() {
return atomicCount;
}
public AtomicLong getAtomicCountCopy() {
return atomicCountCopy;
}
public void addAtomicCount(long increment) {
this.atomicCount.getAndAdd(increment);
this.atomicCountCopy.getAndAdd(increment);
}
}
这种情况下，atomicCount和atomicCountCopy各自的增加是原子的，但是两个变量都增加这个过程是两步，不是原子的。若是a、b两根线程在运行addAtomicCount方法，a线程执行完atomicCount的增加，此时a线程挂起，b线程执行，并且执行了atomicCount和atomicCountCopy的增加，那么此时atomicCountCopy就要比atomicCount小1了，因为a线程还有一半的任务没有执行呢。
java关键字synchronized实现同步
java提供了一种内置的锁机制同步代码块（synchronized block），它包括两部分：锁对象和由锁对象保护的代码块。
- 若synchronized修饰了一段代码，则负责保护一段代码；
synchronized (lock) { // 操作或访问由lock保护的代码块 } - 若修饰了一个方法，则负责保护这个方法的全部代码，锁是当前对象；若synchronized修饰静态方法，那么同步代码块的锁是Class
public class SimpleWorkingHardSingleton {
private static SimpleWorkingHardSingleton simpleSingleton = new SimpleWorkingHardSingleton();
// 数量
private int count;
private int countCopy;
private SimpleWorkingHardSingleton() {
count = 0;
}
public static SimpleWorkingHardSingleton getInstance() {
return simpleSingleton;
}
public int getCount() {
return count;
}
public int getCountCopy() {
return countCopy;
}
public synchronized void addCount(int increment) {
/*
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
System.err.println(e);
}
*/
this.count += increment;
this.countCopy += increment;
System.out.println(this.count);
}
}
上文代码中synchronized对整个方法进行了修饰，那么保护的代码就是方法中的全部代码；这样在多线程环境中，会有序递增地输出count。但是这样有一个潜在问题就是性能问题；
synchronized对整个方法进行了修饰，就会导致这个方法每次只有一个线程可以运行，这就会导致性能问题；假如这个方法中有一个耗时3s的io操作，我们用Thread.sleep(3000);来模拟。然而synchronized保护的代码块本不应该包含这3s的操作，因此代码应该写成：
public void addCount(int increment) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
System.err.println(e);
}
synchronized (this) {
this.count += increment;
System.out.println(this.count);
}
}
上文中两个变量不同步的情况，就可以用synchronized同步代码块来解决；而且使用synchronized要注意，先保证正确性，即可能产生并发问题的共享变量都要放在同步代码块当中；然后再追求性能，即对尽可能短的代码进行保护，也不能太过细化因为锁的使用和释放都是需要代价的。
一个稍微复杂的场景(多看例子多模仿系列)
/**
* 实现带缓存功能的因子分解
*/
public class CachedFactorizer {
private static CachedFactorizer cachedFactorizer = new CachedFactorizer();
// 上一个处理的数字
private long lastNumber;
// 上一个数字分解的结果
private long[] lastFactors;
// 处理数字的次数
private long hits;
// 缓存命中的次数
private long cacheHits;
private CachedFactorizer() {
}
public synchronized long getHits() {
return hits;
}
public synchronized double getCacheHitRatio() {
return (double)cacheHits / (double)hits;
}
public static CachedFactorizer getInstance() {
return cachedFactorizer;
}
public long[] factor(int target) {
// 伪代码，假装实现了因子分解
return new long[] {};
}
public void doFactor(int target) {
Thread.sleep(300);
synchronized (this) {
hits++;
if (target == lastNumber) {
cacheHits++;
} else {
lastNumber = target;
lastFactors = factor(target);
}
}
}
}
- 其实可以在doFactor方法前用synchronized修饰，然而这样不符合性能问题；所以应该用synchronized修饰代码块即可
- getHits和getCacheHitRatio方法加上了synchronized修饰，用的锁就是this，所以和doFactor里面的锁是一样的；因而达到的效果是在doFactor内进行因子计算时候，getHits和getCacheHitRatio方法在阻塞状态
java锁机制的重入
当一个线程请求另一个线程持有的锁的时候，那么请求的线程会阻塞；重入的概念是：当线程去获取自己所拥有的锁，那么会请求成功；重入的原理是：为每个锁关联一个计数器和持有者线程，当计数器为0时候，这个锁被认为是没有被任何线程持有；当有线程持有锁，计数器自增，并且记下锁的持有线程，当同一线程继续获取锁时候，计数器继续自增；当线程退出代码块时候，相应地计数器减1，直到计数器为0，锁被释放；此时这个锁才可以被其他线程获得。
public class Parent {
public synchronized void do() {
}
}
public class Child extends Parent {
@Override
public synchronized void do() {
blabla
super.do();
}
}
如果没有重入机制，那么Child对象在执行do方法时候会发生死锁，因为它拿不到自己持有的锁
参考内容
- 书籍《Java并发编程实战》