多线程自定义锁

  

package lock;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;


/**
 * 自定义锁
 */
public class MyLock implements Lock {
    /** 多线程并发调用
     * 0:未占用锁
     * 1:占用锁
     * 锁的状态
     */
    private AtomicInteger state = new AtomicInteger();

    //当前在等抢锁的
    LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();

    Thread currentThread;

    //没拿到锁就排队等待
    @Override
    public void lock() {
        if(!tryLock()){
            //1先排队
            waiters.add(Thread.currentThread());
            //2 等待
            for (;;){
                if(tryLock()){
                    waiters.poll();//如果一个线程抢到锁了,自己把自己从队列里挪出来
                    return;
                }else{
                    LockSupport.park();//等待
                }
            }

        }

    }



    @Override
    public boolean tryLock() {
        if(state.get() ==0){
            //CAS 底层C++实现 --保证N线程同时操作,只有一个成功
            if(state.compareAndSet(0,1)){
                currentThread = Thread.currentThread();
                return true;
            }
        }
        return false;
    }


    @Override
    public void unlock() {
        if(currentThread !=Thread.currentThread()){
            throw new RuntimeException("锁不属于当前线程");
        }
        if(state.decrementAndGet()==0){
            currentThread = null;
            //通知其他正在等待锁的线程
            Thread thread = waiters.peek();//唤醒后仍然存在,队列中任然存在
            if(thread!=null){
                LockSupport.unpark(thread);//唤醒
            }
        }

    }

    @Override
    public Condition newCondition() {
        return null;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }


    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

}

package lock;

import java.util.concurrent.locks.Lock;

/**
 * 测试案例
 */
public class LockDemo {
    static Lock lock = new MyLock();
    public static void main(String[] args) throws InterruptedException {
        lock.lock();
        Thread th = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始获取锁");
                lock.lock();
                System.out.println("拿到锁了");
                lock.unlock();
                System.out.println("释放锁了");


            }
        });

        th.start();
        Thread.sleep(3000L);
        lock.unlock();
    }

}