简单来说
lock(),等待锁,
tryLock(),尝试锁
lockInterruptibly().可中断锁
lock锁住以后除非锁释放其他线程再进来就会排队,类似syschonize.
tryLock()返回个boolean,让你能够自己去处理,返回true就是你拿到锁了,false就是没有拿到,怎么处理你自己if()else{}
lockInterruptibly()是可中断的,怎么中断来段代码你自己看看
package lock;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadInterruptTest extends Thread {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 3; i++) {
ThreadInterruptTest t = new ThreadInterruptTest();
t.start();
}
Thread.sleep(100);
ThreadInterruptTest t4 = new ThreadInterruptTest();
t4.start();
t4.interrupt();
}
private static AtomicInteger count=new AtomicInteger(0);
private static CyclicBarrier barrier=new CyclicBarrier(4);
private static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
String threadName="当前线程"+ count.addAndGet(1);
Thread.currentThread().setName(threadName);
System.out.println(Thread.currentThread().getName( )+"载入");
try {
lock.lockInterruptibly();
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName( )+"抛出异常");
//e.printStackTrace();
}finally{
lock.unlock();
}
System.out.println(Thread.currentThread().getName( )+"完成");
}
}
简单来说你在外面跑一个线程,原则上来讲是在底层调用C语言生成一个新的线程,这个线程就像妈妈生了孩子,孩子长大了你说了就不算了.你影响不了他,说什么他也不会听了,但是有了Interruptibly你就牛逼了,你在主线程妈妈的位置interrupt()一下子,孩子就得听话,怎么听话呢,如果这是孩子在lock.lockInterruptibly();的时候,就会抛错.
运行结果
当前线程1载入
当前线程3载入
当前线程2载入
当前线程4载入
当前线程4抛出异常
Exception in thread "当前线程4" java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(Unknown Source)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(Unknown Source)
at java.util.concurrent.locks.ReentrantLock.unlock(Unknown Source)
at lock.ThreadInterruptTest.run(ThreadInterruptTest.java:41)
当前线程1完成
当前线程3完成
当前线程2完成
貌似只有最后一个没执行完,是的,道理是说的通的,你告诉四儿子别等了,其他三个还是该干嘛干嘛,简单来说所谓的lock.lockInterruptibly();,就是响应主线程的
t4.interrupt();
起码我是这么理解的,如果有不对的地方或者其他缺失偏差的地方,希望大家留言指正