Lock锁-------tryLock()方法

这一次主要学习Lock接口中的**tryLock()**方法。

tryLock()方法是有返回值的，返回值是Boolean类型。它表示的是用来尝试获取锁：成功获取则返回true；获取失败则返回false，这个方法无论如何都会立即返回。不会像synchronized一样，一个线程获取锁之后，其他锁只能等待那个线程释放之后才能有获取锁的机会。
一般情况下的tryLock获取锁匙这样使用的：

//实例化Lock接口对象
Lock lock = ...;
//根据尝试获取锁的值来判断具体执行的代码
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
     	//当获取锁成功时最后一定要记住finally去关闭锁
         lock.unlock();   //释放锁
     } 
}else {
	//else时为未获取锁，则无需去关闭锁
    //如果不能获取锁，则直接做其他事情
}

具体简单的使用过程如下：

package Lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author jc
 *
 */
public class TryLock {
	//实例化Lock对象
	Lock lock = new ReentrantLock();

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//实例化本类对象，目的是调用runThread方法
		TryLock tl = new TryLock();
		//匿名对象创建线程1，并重写run方法，启动线程
		new Thread(){
			public void run(){
				
				tl.runThread(Thread.currentThread());
			}
		}.start();
		//匿名对象创建线程2，并重写run方法，启动线程
		new Thread(){
			public void run(){
				
				tl.runThread(Thread.currentThread());
			}
		}.start();
		
		
	}
	//线程共同调用方法
	public void runThread(Thread t){
		//lock对象调用trylock()方法尝试获取锁
		if(lock.tryLock()){
			//获锁成功代码段
			System.out.println("线程"+t.getName()+"获取锁成功");
			try {
				//执行的代码
				Thread.sleep(5000);
			} catch (Exception e) {
				//异常处理内容，比如中断异常，需要恢复等
			} finally {
				//获取锁成功之后，一定记住加finally并unlock()方法,释放锁
				System.out.println("线程"+t.getName()+"释放锁");
				lock.unlock();
			}
		}else{
			//获锁失败代码段
			//具体获取锁失败的回复响应
			System.out.println("线程"+t.getName()+"获取锁失败");
		}
	}
}
/**
 * output
 * 线程Thread-0获取锁成功
 * 线程Thread-1获取锁失败
 * 线程Thread-0释放锁
 */

通过代码可以看到，Thread-0获取锁成功，Thread-1获取锁失败直接退出到else中执行else代码块。Thread-0执行sleep()方法过后正常释放锁。

tryLock()有一个重载方法，这个方法就是：**tryLock(long time , TimeUnit unit)**方法，这个方法去限定了一个尝试获取锁的时间。
—获取锁成功则返回true；
—当失败是分为两种情况：
在参数范围内，则不会立即返回值，会等待一段时间，这个时间就是传入的具体参数值，在这个时间内获取锁成功，则依旧返回true；
当过了参数范围后，还是获取锁失败，则立即返回false。
使用过程和tryLock()方法一样：

Lock lock = ...;
//根据尝试获取锁的值来判断具体执行的代码
if(lock.tryLock(long time , TimeUnit unit)) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
     	//当获取锁成功时最后一定要记住finally去关闭锁
         lock.unlock();   //释放锁
     } 
}else {
	//else时为未获取锁，则无需去关闭锁
    //如果不能获取锁，则直接做其他事情
}

具体实现要分情况实现：

1.在参数时间内成功获取锁：

package Lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author jc
 *
 */
public class TryLock {
	//实例化Lock对象
	Lock lock = new ReentrantLock();

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//实例化本类对象，目的是调用runThread方法
		TryLock tl = new TryLock();
		//匿名对象创建线程1，并重写run方法，启动线程
		new Thread(){
			public void run(){
				
				tl.runThread(Thread.currentThread());
			}
		}.start();
		//匿名对象创建线程2，并重写run方法，启动线程
		new Thread(){
			public void run(){
				
				tl.runThread(Thread.currentThread());
			}
		}.start();
		
		
	}
	//线程共同调用方法
	public void runThread(Thread t){
		//lock对象调用trylock(long time , TimeUnit unit)方法尝试获取锁
		try {
			//注意，这个方法需要抛出中断异常
			if(lock.tryLock(5000L,TimeUnit.MILLISECONDS)){
				//获锁成功代码段
				System.out.println("线程"+t.getName()+"获取锁成功");
				try {
					//执行的代码
					Thread.sleep(3000);
				} catch (Exception e) {
					//异常处理内容，比如中断异常
				} finally {
					//获取锁成功之后，一定记住加finally并unlock()方法,释放锁
					System.out.println("线程"+t.getName()+"释放锁");
					lock.unlock();
				}
			}else{
				//获锁失败代码段
				//具体获取锁失败的回复响应
				System.out.println("线程"+t.getName()+"获取锁失败");
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
/**
 * output
 * 线程Thread-0获取锁成功
 * 线程Thread-0释放锁
 * 线程Thread-1获取锁成功
 * 线程Thread-1释放锁
 */

从运行结果可以看到，在等待时间内成功获取了锁。

2.在参数时间内未成功获取锁

package Lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author jc
 *
 */
public class TryLock {
	//实例化Lock对象
	Lock lock = new ReentrantLock();

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//实例化本类对象，目的是调用runThread方法
		TryLock tl = new TryLock();
		//匿名对象创建线程1，并重写run方法，启动线程
		new Thread(){
			public void run(){
				
				tl.runThread(Thread.currentThread());
			}
		}.start();
		//匿名对象创建线程2，并重写run方法，启动线程
		new Thread(){
			public void run(){
				
				tl.runThread(Thread.currentThread());
			}
		}.start();
		
		
	}
	//线程共同调用方法
	public void runThread(Thread t){
		//lock对象调用trylock(long time , TimeUnit unit)方法尝试获取锁
		try {
			//注意，这个方法需要抛出中断异常
			if(lock.tryLock(2000L,TimeUnit.MILLISECONDS)){
				//获锁成功代码段
				System.out.println("线程"+t.getName()+"获取锁成功");
				try {
					//执行的代码
					Thread.sleep(4000);
				} catch (Exception e) {
					//异常处理内容，比如中断异常
				} finally {
					//获取锁成功之后，一定记住加finally并unlock()方法,释放锁
					System.out.println("线程"+t.getName()+"释放锁");
					lock.unlock();
				}
			}else{
				//获锁失败代码段
				//具体获取锁失败的回复响应
				System.out.println("线程"+t.getName()+"获取锁失败");
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
/**
 * output
 * 线程Thread-0获取锁成功
 * 线程Thread-1获取锁失败
 * 线程Thread-0释放锁
 */

从运行结果可以看到，在参数时间内未过去锁，则立即退出尝试获取锁，去执行else内的代码块。