xylz,imxylz

繼續繼續  回复  更多评论
  

Hi

文章结尾的两个参考文献链接失效了。  回复  更多评论
  

“上面的乐观锁用到的机制就是CAS，Compare and Swap”
是Swap？不是Set？
  回复  更多评论
  

请教博主，从网上找了一段模拟CAS的代码，能够实现i++功能，改了一下。开了10000个线程运行，结果是错误的，达不到10000. 为什么？
public class CasCounter {
private SimulatedCAS simulatedCAS = null;
public int getValue(){
return simulatedCAS.getValue();
}

public int increment(){
int oldValue = simulatedCAS.getValue();
while(simulatedCAS.compareAndSwap(oldValue, oldValue+1) != oldValue)
oldValue = simulatedCAS.getValue();
return oldValue;
}

public CasCounter(SimulatedCAS cas){
this.simulatedCAS = cas;
}

public static void main(String[] args) throws InterruptedException {
CasCounter counter = new CasCounter(new SimulatedCAS());
Thread[] ts = new Thread[10000];
for(int i = 0; i <10000; i++){
ts[i] = new CounterThread(counter);

}
for(Thread t : ts){
t.start();
}

for(Thread t : ts){
t.join();
}

System.out.println("counter: "+ counter.getValue());
}
}

public class CounterThread extends Thread {
CasCounter counter = null;

public CounterThread(CasCounter counter) {

this.counter = counter;
}

@Override
public void run() {
counter.increment();
}
}

public class SimulatedCAS {

private volatile int value = 0;
public synchronized int getValue(){
return value;

}
public synchronized int compareAndSwap(int expectedValue, int newValue){
if(value == expectedValue)
value = newValue;
return expectedValue;
}
}
  回复  更多评论
  

@kick
问题可能出在CasCounter.increment()函数中。
多个线程可能取到相同的 oldValue，会导致线程修改失效。
如果给这个函数加上 synchronized差不多就可以了。

不过郁闷的是，加上synchronized以后，也会出现达不到10000的情况。
不过比不加synchronized的情况好的多。不知道是为什么了  回复  更多评论
  

@xxx
@kick

出错的地方在于CAS操作，稍微改动一下：
public synchronized int compareAndSwap(int expectedValue, int newValue) {
if (value == expectedValue) {
value = newValue;
return expectedValue;
}
return - expectedValue;
}
就可以得到正确结果的。通常CAS操作可以返回true/false，如果操作成功返回true，否则返回false。原来的代码是不管操作是否成功都返回了期待值，所以就改变了操作逻辑。
  回复  更多评论
  

@xylz
这里的模拟都使用了synchronized(内在锁)关键字，模拟CAS还有什么意义呢？引入CAS的目的不就是为了较少锁的竞争，提高多线程并发的吞吐率吗？
我觉得要模拟也应该像AQS那样，比如，这是AQS的源码中状态变量的原子操作:

A.Q.S里面包含了一个存储同步状态的变量，它的声明如下：

private volatile int state;

这里采用了volatile修饰符的原因是为了保证对state变量的写对所有的线程都是可见的。但是大家都知道，volatile只能保证变量的可见性，不能保证对变量操作的原子性，所以A.Q.S里面就采用了CAS（Compare And Swap）操作来更新state变量的值，代码如下：

protected final boolean compareAndSetState(int expect, int update)
{ // See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update); }


个人觉得这样才能模拟出CAS的本质，原子特性。
  回复  更多评论
  

@kick
修改2个地方的代码

1.
public int increment() {

for(;;){
int oldValue = simulatedCAS.getValue();
if(simulatedCAS.compareAndSwap(oldValue,oldValue+1)){
oldValue = simulatedCAS.getValue();
return oldValue;
}
}
}

2.
public synchronized boolean compareAndSwap(int expectedValue, int newValue) {
if (value == expectedValue){
value = newValue;
return true;
}
return false;
}  回复  更多评论
  

@zhangxl
您讲的是上面的回复贴出的代码？本来那就是拿来做好玩用的吧。  回复  更多评论
  

@xylz
这个代码不做修改，也可以得到正确的数啊？怎么得不到呢  回复  更多评论
  

“独占锁是一种悲观锁”，这是错误的说法。  回复  更多评论
  

@teasp
别话说一半，解释一下  回复  更多评论
  

@asdf
独占锁既可以是悲观的也可以是乐观的呀，用CAS实现的独占锁不就是乐观的？  回复  更多评论
  

用博主的 int compareAndSwap方法返回- expectedValue，有时会出现9999，用boolean是对的，应该是expectedValue为零时，-0和0是相同的值，导致没有加成功。  回复  更多评论
  

@xylz
SimulatedCAS 类的value 是volatile ，getValue的synchronized 关键字是不是可以去掉了？
  回复  更多评论
  

借这里问个问题哈，java 当中的cas问题，java concurrent 包的实现是依赖 CAS准则实现的，对AtomicInteger 方法中的 compareAndSet方法有些疑惑。
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

unsafe.compareAndSwapInt方法是本地方法， 我考虑这么一种情况：
两个线程T1， T2 同时取了主内存中A， T1调用compareAndSet 方法成功，将A变成 A1， 因为A值是同时从内存中取出来的，那T2调用compareAndSet方法也会成功，将A变成A2. 那结果不是不正确了么。
帮我分析一下啊。
谢啦
  回复  更多评论
  

@vanjayzhou
CAS的CPU原语保证A修改时，T2修改会失败。所以T2才需要循环操作，直到成功。  回复  更多评论
  

@vanjayzhou
老版的CPU会进行锁总线，新版的CPU进行的是缓存锁定。所以T2修改的时候肯定会失败的，因为共享内存已经被CPU锁定了。  回复  更多评论
  

没错是交换设置。  回复  更多评论