synchronized与ReentrantLock底层原理与区别1

   多线程技术是无处不在的,而说到多线程就一定会说到锁,因为要涉及到线程安全,在Java中提供了两种常用锁,synchronized关键字和ReentantLock.
   首先抛出一个老生常谈的问题,既然JAVA已经提供了synchronized关键字作为锁,那么为什么还要提供ReentantLock锁呢?这就涉及到这两者的区别了.

1. 底层原理,使用方式不同.
synchronized是一个关键字,它是依靠JVM的底层实现的,也就意味着加锁和释放锁是自动完成的,每一个对象都有一个monitor监视器,通过监视器判断该对象是否被某个线程持有,具体原理图下图所示.

而ReentantLock是一个类,既然是一个类就拥有自己特有的方法.需要手动加锁和释放锁,需要lock().unlock()方法配合try/finally完成.

2.lock(ReentrantLock实现了lock接口)可用于响应线程中断信息.
   注:ReentrantLock.lock()默认锁的是当前调用对象,和synchronized(this)表达含义一样.
   如代码中所示:

package 线程;

import java.util.concurrent.locks.ReentrantLock;

import sun.applet.Main;

public class MyReentrantLock {
	
	private static ReentrantLock lock=null;
	
	public static void main(String[] args) {
		
		lock= new ReentrantLock();
		//线程1执行任务
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				test();
			}
		},"t1");
		t1.start();
		//间隔0.05秒
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//线程2抢占锁进入等待状态
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				test();
			}
		},"t2");
		t2.start();
		//间隔0.05秒
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("线程2当前状态:"+t2.getState());
		System.out.println("线程1当前状态:"+t1.getState());
		//中断线程
		t2.interrupt();			
		
	}
	
	
	public static void test()  {
		try {
			//该方法允许线程在等待时被中断,直接返回
			lock.lockInterruptibly();
			System.out.println(Thread.currentThread().getName()+"获取到锁,执行操作...");
			Thread.sleep(5000);    //模拟操作,预计耗时5秒
			lock.unlock();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("=====================线程响应中断========================");
		}
	}
	
}

   以上程序很简单,先开启了一个线程1抢占锁,然后线程2也去抢占同一把锁,抢占不到,处于waiting状态,然后这个时候中断线程2.看能否响应中断.

   执行结果如下:

   可以看到线程2并没有执行方法,而是直接被中断返回,而使用synchronized是很难达到这个效果的.
   那么从api层面我们知道lock可以响应中断,但是具体有什么应用场景呢?只有真正理解了应用场景才会更深刻的理解一个知识点.
   这里举一个例子:
       在一个系统中有报表导出的功能,因为涉及到IO操作,所以很浪费系统性能,为了避免很多人同时操作造成系统可用性降低,所以对该功能加上了锁,那么在多人操作时,可能某些用户需要等待,在客户等待的过程中,如果有客户想要取消,这个功能要怎么实现?

   补充一下lock()和lockInterruptibly()方法的区别:

    ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。
   ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态.然后在适当的位置通过调用isInterrupted方法来查看自己是否被中断，并做退出操作

3.ReentrantLock提供了tryLock()方法,可以不需要等待,直接返回结果.
   代码如下所示:

package 线程;

import java.util.concurrent.locks.ReentrantLock;

import sun.awt.SunHints.LCDContrastKey;

public class MyReentrantLock2 {
	
	
	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock();
		new Thread(new Runnable() {
			@Override
			public void run() {
				test(lock);
				
			}
		},"t2").start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				test(lock);
				
			}
		},"t1").start();
		
	}
	
	public static void test(ReentrantLock lock) {
		//尝试获取锁,获取不到无需等待,直接返回
		if(lock.tryLock()) {
			System.out.println(Thread.currentThread().getName()+"获取锁,开始执行...");
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			lock.unlock();
		}else {
			System.out.println(Thread.currentThread().getName()+"没有获取到锁,直接返回...");
		}
		
	}

}

   执行结果如下所示:

可以看到两个线程t1和t2,当一个线程先获取到锁之后,另外一个不会等待,直接返回

   tryLock()适用于同一时间只需要一个线程去做的场景,那么具体适用于哪些场景呢?
   可能一些人会不假思索的说到抢票,秒杀,但是这些是我们都能接触到的嘛?这里面涉及到的知识点我们都懂嘛?尤其在面试的时候,这样很容易给自己挖坑.
   这里介绍一个较为常见的场景.在我们登录中,会有session,通常session会有一个过期时间,假设是三十分钟,为了对用户状态进行更新,用户每发起一个请求,我们就更新session,但是我们知道,当打开一个页面,浏览器会同时发起n多个请求,而此时我们仅仅需要处理其中的一个请求去更新session即可,就会用到trylock().

4.使用ReentrantLock锁进行同步操作的小例子
该样例源于LeetCode的一个多线程算法题,地址如下:LeetCode多线程第二题,需要注意的是使用ReentrantLock进行等待唤醒操作时,需要用到Condition类,该实例支持与 Object 的监视器方法（wait、notify 和 notifyAll）相同的用法.

class FooBar {
    private int n;
    private AtomicInteger flag = new AtomicInteger(0);
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public FooBar(int n) {
        this.n = n;
    }

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                if (flag.get() != 0) {
                    condition.await();  //线程等待
                }

                printFoo.run();
                flag.set(1);
                condition.signal();    //线程唤醒
            } finally {
                lock.unlock();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                if (flag.get() != 1) {
                    condition.await();    
                }

                printBar.run();
                flag.set(0);
                condition.signal();
            } finally {
                lock.unlock();
            }
        }
    }
}

newCondition方法在API中的官方解释

补充:
      当一个等待线程被唤醒之后有可能获得CPU,并需要重新获取锁,当获取成功后继续执行剩余的代码