import java.lang.reflect.Field;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

import sun.misc.Unsafe;


/**
 * 简单的重入锁
 * @version 1.0
 * @author jimmyyong
 *
 */
public class SimpleReentrantLock {
    
    
    private volatile static Unsafe unsafe;
    
    /** state内存地址给cas操作用的*/
    private volatile static long stateoffset;
    private volatile static long headoffset;
    private volatile static long tailoffset;
    private volatile static long waitoffset;
    
    /** 锁的状态，不为0表示有线程占有锁*/
    public volatile int state;
    
    public volatile Node head = new Node();
    public volatile Node tail = head;

    
    SimpleReentrantLock(){
        
        
    }
    
    /**
     * 获取锁，可重入
     * @return true：获取锁成功   false：获取锁失败
     */
    public void lock(){
        //if(!tryAcquire(1))
            acquire(1);   
    }
    
    /**
     * 释放锁，可重入
     * @return true：获取锁成功   false：获取锁失败
     */
    public boolean unlock(){
        for(;;){
            if(setCASWait(head,2, 0)){
                if(state-1 == 0){
                    Node next = head.next;
                    if(next != null){
                        if(next.next != null){
                            head.next = next.next;
                        }
                        unsafe.unpark(next.thread);
                    }
                }
                state=state-1;
                setCASWait(head,0, 2);
                return true;
            }
        }
    }
    
    /**
     * 获取锁
     * @param i
     * @return
     */
    public void acquire(int i){
        for(;;){
            try{
                if(tryAcquire(1)){
                    
                    return;
                }
                Node node = new Node();
                node.thread = Thread.currentThread();
                
                if(addQueue(node)){
                    setCASWait(head,1, 2);
                    return;
                }
                LockSupport.park();
            }finally{
                //  ****
            }
        }
    }    
    
    
    /**
     * 尝试获取锁
     * @param 增量数字
     * @return 获取锁是否成功
     */
    public boolean tryAcquire(int i){
        if(setCASState(0,i)){
            return true;
        }
        return false;
    }
    
    /**
     * 添加等待队列
     * @param node
     * @return
     */
    public boolean addQueue(Node node){
        for(;;){
            if(setCASWait(head,2, 1)){
                if(tryAcquire(1)){
                    return true;
                }
                Node oldtail = tail;
                if(setCASTail(oldtail, node)){
                    oldtail.next = node;        // 竞技条件
                    setCASWait(head,1, 2);
                    return false;    
                }
            }
        }
    }
    
    /**
     * 操作堆外内存
     * @return
     */
    public static Unsafe getUnsafe(){
        Field f1;
        try {
            f1 = Unsafe.class.getDeclaredField("theUnsafe");
            f1.setAccessible(true);
            return (Unsafe) f1.get(null);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return null;
    }
    
    /**
     * cas赋值state
     * @param exche     判断值
     * @param update    更新值
     * @return true：表示修改成功，false修改失败
     */
    public boolean setCASState(int exche,int update){
        return unsafe.compareAndSwapInt(this, stateoffset, exche, update);
    }
    
    /**
     * cas赋值head
     * @param exche     判断值
     * @param update    更新值
     * @return true：表示修改成功，false修改失败
     */
    public boolean setCASHead(Node exche,Node update){
        return unsafe.compareAndSwapObject(this, headoffset, exche, update);
    }
    
    /**
     * cas赋值tail
     * @param exche     判断值
     * @param update    更新值
     * @return true：表示修改成功，false修改失败
     */
    public boolean setCASTail(Node exche,Node update){
        return unsafe.compareAndSwapObject(this, tailoffset, exche, update);
    }
    
    /**
     * cas赋值tail
     * @param exche     判断值
     * @param update    更新值
     * @return true：表示修改成功，false修改失败
     */
    public boolean setCASWait(Node obj,int exche,int update){
        return unsafe.compareAndSwapInt(obj, waitoffset, exche, update);
    }
    
    /** 给内存地址赋值 */
    static{
        unsafe = getUnsafe();
        try {
            stateoffset = unsafe.objectFieldOffset(SimpleReentrantLock.class.getField("state"));                
            headoffset = unsafe.objectFieldOffset(SimpleReentrantLock.class.getField("head"));    
            tailoffset = unsafe.objectFieldOffset(SimpleReentrantLock.class.getField("tail"));
            waitoffset = unsafe.objectFieldOffset(Node.class.getField("wait"));    
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }
    
    static class Node{
        /**1表示可释放锁 2都可以  3表示可获取锁 */
        public volatile int wait = 2;
        volatile Node next;
        volatile Thread thread;
    }
    
    
    public static void main(String[] args) throws InterruptedException {
        final SimpleReentrantLock  lock = new SimpleReentrantLock();
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                lock.lock();
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("xieyong1");
                lock.unlock();
            }
        });
        
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                    lock.lock();
                    System.out.println("xieyong2");
                    lock.unlock();
            }
        });
        
        
        
        thread1.setName("xieyong1");
        thread2.setName("xieyong2");
        thread1.start();
        thread2.start();
        //thread4.start();
    }
    
}

 上面这锁还有些问题:效率问题，重入问题，有时间发布第二篇博客