并发带来的问题
先看一个单例类,后文中都会用到:
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并发编程实战》