java实现自己的多个线程同时访问的读锁

 1.写自己的多个读线程的同时访问类

package lock.mycountdownlatch;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MySelfLock implements Lock {

    //声明一个类继承AbstractQueuedSynchronizer
    public   final class Sync extends AbstractQueuedSynchronizer {
        
        //构造方法中传入可以同时允许有几个线程访问
         Sync(int count) {
                if (count <= 0) {
                    throw new IllegalArgumentException("count must large than zero.");
                }
                //如果不为0，则表示传入了正确的值，则设置当前状态值为可传入的线程数
                setState(count); 
            }
         
        @Override
        protected int tryAcquireShared(int arg) {
            //开始自旋一直尝试获取锁
            for(;;){
                //获取当前状态
                int currentState = getState();
                // 获取线程应该将state减去1 ，获取我期望改成的状态，当前状态减去当前进来的线程数
                int newState = currentState-arg;
                //用compareAndSetState判断是否可以拿,newState < 0 这个判断写在前面表示如果小于0表示没有线程，则返回负数表示获取失败，如果大于或者等于0进行第二个判断表示可以拿到线程
                if(newState < 0 || compareAndSetState(currentState, newState)){
                    System.out.println("-------------"+newState);
                    return newState;
                } 
            }
            
         }    

        @Override
        protected boolean tryReleaseShared(int arg) {
             for (;;) {
                    int current = getState();
                    int newCount = current + arg;
                    if (compareAndSetState(current, newCount)) {
                        return true;
                    }
                }
        }
        
    }
    
     //为n表示允许n个线程同时获得锁
    private final Sync sync = new Sync(3);
    
    public void lock() {
        sync.acquireShared(1);
    }

    public void unlock() {
        sync.releaseShared(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // TODO Auto-generated method stub
        
    }

    @Override
    public boolean tryLock() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // TODO Auto-generated method stub
        return false;
    } 

    @Override
    public Condition newCondition() {
        // TODO Auto-generated method stub
        return null;
    }

    
    
    
}
 

2.编写测试类

package lock.mylock;

import java.util.concurrent.locks.Lock;

import lock.mycountdownlatch.MySelfLock;
import util.SleepTools;

public class TestMyLock {

    public void test(){
        //创建一个自己的锁对象
        final Lock lock = new MySelfLock();
        //写一个方法局部类继承线程
        class Worker extends Thread{
            @Override
            public void run() {
                //拿锁后打印
                lock.lock();
                System.out.println(Thread.currentThread().getName());
                try{
                    SleepTools.second(1);
                }finally {
                    //做完事情后解锁
                    lock.unlock();
                }
            }
        }
        
        //4个线程执行
        for(int i = 0 ; i < 10 ; i ++){
            Worker w = new Worker();
            w.start();
        }
        
    }
    
    public static void main(String[] args) {
        TestMyLock testMyLock = new TestMyLock();
        testMyLock.test();        
    }
    
}