class MyLock {
    private boolean locked = false;
    public boolean lock() {
        if(!locked) {
            locked = true;
            return true;
        }
        return false;
    }
}

class MyLock {
    private boolean locked = false;
    public synchronized boolean lock() {
        if(!locked) {
            locked = true;
            return true;
        }
        return false;
    }
}

public static class MyLock {
    private AtomicBoolean locked = new AtomicBoolean(false);
    public boolean lock() {
        return locked.compareAndSet(false, true);
    }
}

private AtomicInteger atomicI = new AtomicInteger(0);
       private int i = 0;
       public static void main(String[] args) {
              final Counter cas = new Counter();
              List<Thread> ts = new ArrayList<Thread>(600);
              long start = System.currentTimeMillis();
              for (int j = 0; j < 100; j++) {
                     Thread t = new Thread(new Runnable() {
                            @Override
                            public void run() {
                                   for (int i = 0; i < 10000; i++) {
                                          cas.count();
                                          cas.safeCount();
                                   }
                            }
                     });
                     ts.add(t);
              }
              for (Thread t : ts) {
                     t.start();
              }
              // 等待所有线程执行完成
              for (Thread t : ts) {
                     try {
                            t.join();
                     } catch (InterruptedException e) {
                            e.printStackTrace();
                     }
              }
              System.out.println(cas.i);
              System.out.println(cas.atomicI.get());
              System.out.println(System.currentTimeMillis() - start);
       }
       /**
        * 使用CAS实现线程安全计数器
        */
       private void safeCount() {
              for (;;) {
                     int i = atomicI.get();
                     boolean suc = atomicI.compareAndSet(i, ++i);
                     if (suc) {
                            break;
                     }
              }
       }
       /**
        * 非线程安全计数器
        */
       private void count() {
              i++;
       }
}

/**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return true if successful
     */
    public boolean compareAndSet(V   expectedReference,//预期引用
                                 V   newReference,//更新引用
                                 int expectedStamp,//以前的版本
                                 int newStamp)//更新版本

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABA {
	private static AtomicInteger atomicInt = new AtomicInteger(100);
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private static AtomicStampedReference atomicStampedRef = new AtomicStampedReference(100, 0);
	public static void main(String[] args) throws InterruptedException {
		Thread intT1 = new Thread(new Runnable() {
			@Override
			public void run() {
                //1
				atomicInt.compareAndSet(100, 101);
				//2
                atomicInt.compareAndSet(101, 100);
			}
		});
		//3 
		Thread intT2 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
				}
                //4
				boolean c3 = atomicInt.compareAndSet(100, 101);
				System.out.println("[AtomicInteger]ABA问题：" + c3); // 交换成功true
			}
		});
		intT1.start();
		intT2.start();
		intT1.join();
		intT2.join();
        //5 
		Thread refT1 = new Thread(new Runnable() {
			@SuppressWarnings("unchecked")
			@Override
			public void run() {
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
				}
				//6 
				boolean c = atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
				
				System.out.println("线程1,第1次交换后101版本：" + atomicStampedRef.getStamp()); 
				//7 
				boolean c1 = atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
				
				System.out.println("线程1,第2次交换100版本：" + (atomicStampedRef.getStamp()));
				System.out.println("线程1,第1次交换：" + c);
				System.out.println("线程1,第2次交换：" + c1);
			}
		});
		Thread refT2 = new Thread(new Runnable() {
			@Override
			public void run() {
				int stamp = atomicStampedRef.getStamp();
				try {
					TimeUnit.SECONDS.sleep(2);
				} catch (InterruptedException e) {
				}
				//8 
				@SuppressWarnings("unchecked")
				boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
				System.out.println("线程2,第1次交换：" + c3);// false
			}
		});
		refT1.start();
		refT2.start();
	}
}

// setup to use Unsafe.compareAndSwapInt for updates  
private static final Unsafe unsafe = Unsafe.getUnsafe();

static {  
     try {  
       valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));  
     } catch (Exception ex) { throw new Error(ex); }  
}

public native long objectFieldOffset(Field f);

public final void lazySet(int newValue) {  
        unsafe.putOrderedInt(this, valueOffset, newValue);  
}

public final boolean compareAndSet(int expect, int update) {  
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
}

public final boolean weakCompareAndSet(int expect, int update) {  
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
}

import java.lang.reflect.Field;
import sun.misc.Unsafe;
/**
 * Unsafe代码测试
 * 
 * @author Administrator
 *
 */
public class UnsafeTest {
	private static Unsafe unsafe;
	static {
		try {
			// 通过反射获取rt.jar下的Unsafe类
			Field field = Unsafe.class.getDeclaredField("theUnsafe");
			field.setAccessible(true);
			// 实例化对象
			unsafe = (Unsafe) field.get(null);
		} catch (Exception e) {
			System.out.println("Get Unsafe instance occur error" + e);
		}
	}
	public static void main(String[] args) throws Exception {
		@SuppressWarnings("rawtypes")
		Class clazz = Target.class;
		Field[] fields = clazz.getDeclaredFields();
		System.out.println("属性的偏移量fieldName:fieldOffset");
		for (Field f : fields) {
			// 获取属性偏移量，可以通过这个偏移量给属性设置
			System.out.println("属性名字：" + f.getName() + "，类型：" + f.getType() + "，偏移量:" + unsafe.objectFieldOffset(f));
		}
		Target target = new Target();
		Field intFiled = clazz.getDeclaredField("intParam");
		int a = (Integer) intFiled.get(target);
		System.out.println("intParam初始化值是:" + a);
		// intParam的字段偏移是12, 初始化值3, 我们要改为10
		System.out.println("改变成偏移量10："+unsafe.compareAndSwapInt(target, 12, 3, 10));
		int b = (Integer) intFiled.get(target);
		System.out.println("intParam改变之后的值是:" + b);
		// 这个时候已经改为10了,所以会返回false
		System.out.println("这个时候已经改为10,不是12；所以交换失败，intParam:" + unsafe.compareAndSwapInt(target, 12, 3, 10));
		System.out.println("偏移量24,值是null:" + unsafe.compareAndSwapObject(target, 24, null, "5"));
		//int c = (Integer) intFiled.get(target);
		//System.out.println("偏移量24,值是null,改变之后的值" + c);
	}
}
class Target {
	int intParam = 3;
	long longParam;
	String strParam;
	String strParam2;
}