lockInterruptibly 和lock的区别

这是个被无数人写过并还会被其他人继续写下去的blog。

代码如下：

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

public class TestLock {

	public static void main(String[] args) {
		Thread t1 = new Thread(new RunTt3());
		Thread t2 = new Thread(new RunTt3());
		
		t1.start();
		t2.start();
		t2.interrupt();
	}
}

class RunTt3 implements Runnable {

	private static Lock lock = new ReentrantLock();
	
	@Override
	public void run() {
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + " running");  
            TimeUnit.SECONDS.sleep(5);  
            System.out.println(Thread.currentThread().getName() + " finished"); 
		} catch(InterruptedException e) {
			System.out.println(Thread.currentThread().getName() + " interrupted");  
		} finally {
			lock.unlock();
		}
	}
}

 执行结果如下：

 

（1）：

 

Thread-1 running
Thread-1 interrupted
Thread-0 running
Thread-0 finished

 （2）：

 

 

Thread-0 running
Thread-0 finished
Thread-1 running
Thread-1 interrupted

 总结：
1、线程的执行是无序的，及线程的执行顺序不是按照线程的提交顺序来执行。上述代码中，t1的线程可以先执行；
2、使用显示式锁（ReentrantLock），一定要在finally代码块中释放锁；

 

 

当代码：

lock.lock();

 修改成：

lock.lockInterruptibly();

 执行结果如下：

Exception in thread "Thread-1" Thread-0 running
Thread-1 interrupted
java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:155)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1260)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:460)
	at com.bohaisoft.concurrent.RunTt3.run(TestLock.java:33)
	at java.lang.Thread.run(Thread.java:745)
Thread-0 finished

 总结：

2、使用lockInterruptibly需要记住：当前线程可以被其他线程中止，并且在其他线程中抛出异常信息；
3、使用lock需要记住：当前线程也可以被其他线程中止，但不会抛出异常信息；

 

来自其他网站上的总结：

ReentrantLock获取锁定与三种方式：
a)lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁
b)tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；
c)tryLock(long timeout,TimeUnit unit)，   如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；
d)lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断；

 

我的总结：

synchronized 与 Lock的区别主要表现在：
1、lock支持可判定是否能获取锁的操作，如果不能获取锁，则可以补尝处理，避免等待；
2、lock支持设置等待时间，避免无限制等待；
3、lock支持其他线程中止真在运行的线程；