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鎖定了。  回復  更多評論
  

沒錯是交換設置。  回復  更多評論