lock接口认识及可重入锁的实现

 Lock接口中有lockInterruptibly方法（线程中断）,tryLock方法（获取锁成功返回成功，获取锁失败返回失败）,还有就是锁的公平性问题，还有就是提供读写性能的ReadWriteLock等等。

 Lock需要显示地获取和释放锁，繁琐，能让代码更加灵活

 Synchronized不需要显示地获取和释放锁，简单。

 使用Lock可以方便的实现公平性

 非阻塞的获取锁

 能被中断的获取锁

 超时获取锁

public class Sequence {
    
    private int value;
    
    Lock lock = new ReentrantLock();
    
    
    public int getNext() {
        lock.lock();
        int a = value ++;
        lock.unlock();
        return a;
    }
    
    
    public static void main(String[] args) {
        Sequence s = new Sequence();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName()+ " "+s.getNext());
                    
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName()+ " "+s.getNext());
                    
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

}

2，可重入锁的实现

//Demo.java

public class Demo {
    
    MyLock lock = new MyLock();
    
    public void a() {
        lock.lock();  //1
        System.out.println("a");
        b();  
        lock.unlock(); //4
    }

    public void b() {
        lock.lock();  //2
        System.out.println("b"); 
        lock.unlock();  //3
    }
    
    
    
    
    public static void main(String[] args) {
        Demo d = new Demo();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                d.a();
            }
            
        }).start();
        
        

    }
}

public class MyLock implements Lock {

    private boolean isLocked = false;
    
    private Thread lockBy = null;
    
    int lockCount = 0;
    
    @Override
    public synchronized void lock() {
        
        Thread currentThread = Thread.currentThread(); //1,第一个线程Thread-0 islocked = false 
        //2 thread-0再次进入lock方法 当前线程还是thread-0
        while(isLocked && currentThread != lockBy) //1，跳过 2，islock=true ,currentThread = lockby,跳过
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isLocked = true;     //1
        lockBy = currentThread; //1把当前线程指定为lockby
        lockCount ++; //1 lockCount=1    
        //2 lockCount =2
        
    }
    
    

    @Override
    public synchronized void unlock() {
        if(lockBy == Thread.currentThread()) {
            lockCount --;  // 3 ,lockcount = 1
            //4 lockcount = 0
            if(lockCount == 0 ) {
                notify();        //4
                isLocked =false; //4
            }
        }

    }

    
    
    @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;
    }

}