并发编程之深入理解Lock接口

写一个线程不安全的代码：

public class UnsafeThread {
    private static int num = 0 ;
    private static CountDownLatch countDownLatch = new CountDownLatch(10);

    public static void inCrease(){
        num++;
    }

    public static void main(String[] args) {
        for(int i =0;i<10;i++){
            new Thread(()->{
                for(int j=0;j<100;j++){
                    inCrease();
                    try {
                        Thread.sleep(10L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                countDownLatch.countDown();
            }).start();

        }

        while (true){
            if(countDownLatch.getCount()==0){
                System.out.println(num);
                break;
            }
        }
    }
}

这里的CountDownLatch 是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程执行完后再执行。一个线程运行结束后要调用countDown方法操作，实际就是释放锁的操作，每调用一次，计数值减少 1。
这里是模拟10个线程，每个线程执行的任务是让num++100次，最后num的结果应是1000。运行上面的代码，线程不安全，每次返回结果都不一致。

可以加synchronized关键字

public static synchronized void inCrease(){
    num++;
}

在运行的方法上，使其变成线程安全的方法，也可用Lock接口的方法加锁：

private static Lock lock = new ReentrantLock();
public static  void inCrease(){
    lock.lock();
    num++;
    lock.unlock();
}

每次启用锁要调用lock()方法，结束后要用unlock()来释放锁。
对于Lock接口里的方法进行了学习，有如下解释：

• void lock();

  尝试去获得锁。 如果锁不可用，则为了线程调度的目的，当前线程会变得不可用，直到获得锁为止。

• void lockInterruptibly() throws InterruptedException;
  尝试去获得锁，除非当前线程被中断。 如果锁不可用，则为了线程调度的目的，当前线程会变得不可用，直到出现以下两种情况之一：

  当前线程获取锁。 其他的线程中断了这个线程。
  如果当前线程在获取锁操作中，被其他线程中断，则会抛出InterruptedException异常，并且将中断标识清除。
  boolean tryLock();
  只有在调用时锁是空闲的，才获取锁。
  如果锁空闲，则获取锁，并立即返回true值。
  如果锁不可用，则立即返回false值。

• boolean tryLock(long time, TimeUnit unit) throws
  InterruptedException; 如果在限定时间内，锁可用并且当前线程不被中断，则获取锁。
  如果锁空闲，则获取锁，并立即返回true值。 如果锁不可用，则为了线程调度的目的，当前线程会变得不可用，直到出现以下三种情况之一：

  1、 当前线程获取锁。
  2、其他的线程中断了这个线程。
  3、限定时间超时。
  针对上面三种情况，当前方法会分别作出以下操作：

  如果获得锁，则即返回true值。
  如果当前线程在获取锁操作中，被其他线程中断，则会抛出InterruptedException异常，并且将中断标识清除。
  如果限定时间超时，则即返回false值。

• void unlock();
  释放锁。

• Condition newCondition();
  获取一个绑定到当前Lock对象的Condition对象。
  获取Condition对象的前提是当前线程持有Lock对象。

对于lock与synchronized关键字的区别：

• lock： 获取锁与释放锁的过程，都需要程序员手动的控制

  Lock用的是乐观锁方式。所谓乐观锁就是，每次不加
  锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就 是 CAS操作

• syncronized托管给jvm执行，原始采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。