Lock接口中的几个方法讨论

显示锁Lock和ReentrantLock

Lock 是一个接口，提供了无条件的、可轮询的、定时的、可中断的锁获取操作，所有加锁和解锁的方法都是显示的。核心方法有lock()、unlock()、tryLock()，实现类有ReentrantLock、ReentrantReadWriteLock.ReadLock、ReentrantReadWriteLock.WriteLock

void lock()
拿不到lock就不罢休，不然线程就一直block，调用方法结束后，要是用unlock，否则会造成死锁

代码结构示例：

public void m(){
        lock.lock();
        try {

        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            lock.unlock();
        }
    }

boolean tryLock()
马上返回，拿到lock就返回true，不然返回false;通常对于那种不必获取锁的操作可能有用，注意必须拿到锁的方法才可调用unlock()方法

import java.util.concurrent.locks.ReentrantLock;
public class LockTest {

    ReentrantLock lock = new ReentrantLock();
    public void tryLockTest(){
        try {
            boolean getLock = lock.tryLock();
            if(getLock){
                System.out.println("Thead----"+Thread.currentThread().getName()+"---get lock---");
                Thread.sleep(10);
                lock.unlock();//必须拿到锁的线程才可调用此方法，否则抛异常
            }else{
                System.out.println("Thead----"+Thread.currentThread().getName()+"---not get lock---");
                Thread.sleep(10);
            }       
        }catch(Exception e){
            System.out.println(Thread.currentThread().getName()+"异常");
            e.printStackTrace();
        }
    }
}

运行结果：

由结果可以看出，只有第一个线程获取到锁。

boolean tryLock(long ParamLong,TimeUnit ParamTimeUnit) throws InterruptedException

带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false

图中画红框部分是经修改的代码，修改后的执行结果如下

当线程没有拿到lock，要等一会，超时后仍没有拿到，才会返回false

void lockInterruptibly() throws InterruptedException

优先考虑响应中断，而不是响应锁定的普通获取，当外部线程被Interrupted，则当线程调用lockInterruptibly时进入catch方法中，若外部线程没有被打断，则与功能与调用lock方法一致

代码进行如下修改

子方法中调用lockInterruptibly()

主方法中，将一些线程打断

下面我们看一下执行结果

Lock与synchronized比较
1、lock使用起来更加灵活，但是必须有释放锁的动作配合
2、lock适用于代码块，而synchronized是对象之间的互斥锁

注意以下两种方式的区别

第一种方式：两个方法之间的锁是独立的

public class MainT {

    /**
     * @param args
     */
    public static void main(String[] args) {
        final LockTest lt = new LockTest();
        //final LockTest lt2 = new LockTest();
        // TODO Auto-generated method stub
        for(int i=0;i<2;i++){
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    lt.get();
                }
            });
            t1.start();
        }
        for(int i=0;i<2;i++){
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    lt.put();
                }
            });
            t1.start();
        }
    }

}

import java.util.concurrent.locks.ReentrantLock;


public class LockTest {

    public  void get(){
        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"----get begin---");
            Thread.sleep(1000);//模仿干活
            System.out.println(Thread.currentThread().getName()+"----get end---");
            lock.unlock();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

    public void put(){
        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"----put begin---");
            Thread.sleep(1000);//模仿干活
            System.out.println(Thread.currentThread().getName()+"----put end---");
            lock.unlock();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

每个调用此方法的锁都是独立的，没有起到锁的用途

第二种方式：两个方法之间使用相同的锁

    /**
     * @param args
     */
    public static void main(String[] args) {
        final LockTest lt = new LockTest();
        // TODO Auto-generated method stub
        for(int i=0;i<2;i++){
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    lt.get();
                }
            });
            t1.start();
        }
        for(int i=0;i<2;i++){
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    lt.put();
                }
            });
            t1.start();
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
    ReentrantLock lock = new ReentrantLock();
    public  void get(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"----get begin---");
            Thread.sleep(1000);//模仿干活
            System.out.println(Thread.currentThread().getName()+"----get end---");
            lock.unlock();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

    public void put(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"----put begin---");
            Thread.sleep(1000);//模仿干活
            System.out.println(Thread.currentThread().getName()+"----put end---");
            lock.unlock();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

两个线程调用方法使用的同一个锁，所以串行执行；结果如下图所示