1 可以手动实现一个类似reentrantlock的工具，首先要维护一个state的标志，代表当前是否有线程已经使用资源。线程lock的时候，
会用cas给state加1，其他线程检测状态。另外需要维护一个等待队列，争夺不到资源的线程统一挂起（park），等线程unlock的时候，
标志减为0，同时从队列里挑一个线程unpark唤醒，继续得到资源操作；如果想让队列线程竞争，就都唤醒，最终只有一个得到资源。
这是实现了基本的锁。
public class LkLock {
private ReentrantLock lock;
private Thread ownerThread;
private LinkedBlockingQueue<Thread> waitList = new LinkedBlockingQueue<Thread>(10000);
private static Unsafe unsafe =null;
private int state=0;
private static long stateOffset;
public LkLock(){
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference
f.setAccessible(true);
unsafe = (Unsafe) f.get(null);
stateOffset= unsafe.objectFieldOffset(LkLock.class.getDeclaredField("state"));
} catch (Exception e) {
System.out.println(e+" error");
}
}
public void lock(){
if(compareAndSetState(0,1)){
ownerThread=Thread.currentThread();
}else{
acquire(1);
}
}
public void unlock(){
compareAndSetState(1,0);
if(!CollectionUtils.isEmpty(waitList)){
Thread t=waitList.poll();
LockSupport.unpark(t);
}
}
private void acquire(int i){
try {
//加入等待队列
waitList.put(Thread.currentThread());
//挂起
LockSupport.park();
} catch (InterruptedException e) {
System.out.println(e);
}
}
public int getState() {
return state;
}
private boolean compareAndSetState(int src, int target){
return unsafe.compareAndSwapInt(this, stateOffset, src, target);
}
}
2 同样 如果想要实现能够重入的读写锁，读可重入，写唯一，并且读写互斥，那么需要用两个资源分别给读写的线程竞争，
读的资源可累加，每次线程readlock的时候加一，不设上限；写的线程如上面只可唯一线程获得资源。并且无论读写线程竞争资源之前，
都要检测对方资源是否已经被占用，如果占用也要挂起，这样可以达到互斥。改动如下
public void readLock(){
if(writeState!=0){
acquire();
}
if(compareAndSetReadState(readState,readState+1)){
System.out.println(readState+" 读 我看到的 "+Thread.currentThread());
}else{
acquire();
}
}
public void readUnlock(){
compareAndSetReadState(readState,readState-1);
if(!CollectionUtils.isEmpty(waitList)){
while (waitList.size()!=0){
Thread t=waitList.poll();
LockSupport.unpark(t);
}
}
}
public void writeLock(){
if(readState!=0){
acquire();
}
if(compareAndSetWriteState(0,1)){
System.out.println(writeState+" 写 我看到的 "+Thread.currentThread());
}else{
acquire();
}
}
public void writeUnlock(){
compareAndSetWriteState(1,0);
if(!CollectionUtils.isEmpty(waitList)){
while (waitList.size()!=0){
Thread t=waitList.poll();
LockSupport.unpark(t);
}
}
}