正如所提到的,
Java语言还提供了另一种较弱的同步形式,即易失性变量,以确保对变量的更新可预测地传播到其他线程。
所以我的理解是
下面的代码使用锁(synchronized)提供(互斥+内存可见性),
public class SynchronizedInteger{
private int value;
public synchronized int get(){ return value; }
public synchronized void set(int value){ this.value = value; }
}
也可以使用volatile关键字
创建数组:
使用启动时提供的线程,因为我们只创建了一次数组。
public static final Player[] PLAYERS = new Player[10];
写入数组:
从一个池中使用几个不同的线程,以便播放器可以同时加载。
public static Player loadPlayer(int freeIndex) {
//slow code that loads the player's saved data.
return PLAYERS[freeIndex] = player;
}
从数组读取:
使用单个线程按索引顺序处理播放机。
这个类是线程安全的吗?
是否有可能看到不一致的值?假设最初a的值是80。线程1调用setA(100)并进入函数,但尚未调用a.set(100),线程2同时调用getA()。线程2有可能看到80吗?
public class A {
private AtomicInteger a;
public int getA() {
return a.get()
}
public void setA(int newVal){
a.set(newVal);
}
}
我知道同步它将保证线程2看到100,但对于AtomicInte
代码来自ArrayBlockingQueue,Java8。评论说:锁定只是为了可见性,而不是互斥。
final Object[] items;
int putIndex;
int count;
public ArrayBlockingQueue(int capacity, boolean fair,
Collection<? extends E> c) {
this(capacity, fair);
final ReentrantLock lock = th
原子/易失性/同步如何在内部工作?
以下代码块之间有什么区别?
代码1
private int counter;
public int getNextUniqueIndex() {
return counter++;
}
代码2
private AtomicInteger counter;
public int getNextUniqueIndex() {
return counter.getAndIncrement();
}
代码3
private volatile int counter;
public int getNextUniqueIndex() {