1.jdk中罕用的独占锁有两种:Synchronized,ReenTrantLock。两种锁在性能上差异不大,但ReenTrantLock手动加锁，解锁，更加灵便，性能更加丰盛
1)独占锁,可重入锁
public class TestReenTrantLock { static Lock lock = new ReentrantLock(true); public static void main(String[] args) { //可重入锁:一个线程屡次获取同一个对象上的锁。可重入锁的意义之一在于避免死锁 实现原理:当线程获取锁时，jvm将记录锁的占有者，并将锁中的计数器加1，同一个线程再次取得锁，计数器再次加1。未被占用的锁，计数器为0。当线程退出同步块，计数器值将递加，直到计数器值为0，锁被开释。其余线程能力取得锁 独占锁:一个锁一次只能被一个线程占有 method(); method1(); lock.unlock(); lock.unlock(); } public static void method(){ lock.lock(); System.out.println("第一次获取锁"); } public static void method1(){ lock.lock(); System.out.println("第二次获取锁"); }}这里在method中获取了TestReenTrantLock类锁,调用method1时再一次获取了TestReenTrantLock类锁,这就是可重入锁
2)能够实现偏心锁
public class FairReenTrantLock { /** * 偏心锁：当锁可用时,在锁上等待时间最长的线程获取锁的使用权 * 无参数或为fasle，为非偏心锁 * 非偏心锁：随机取得锁的使用权 */ static Lock lock = new ReentrantLock(true); public static void main(String[] args) { for (int i=0; i<5; i++){ new Thread(new ThreadDemo()).start(); } } static class ThreadDemo implements Runnable{ public ThreadDemo(){ } @Override public void run() { try { TimeUnit.SECONDS.sleep(2); }catch (Exception e){ e.printStackTrace(); } for(int i=0; i<2; i++){ lock.lock(); System.out.println("取得锁的线程"+Thread.currentThread().getName()); lock.unlock(); } } }}3)能够响应线程中断
- 首先理解一下 public void interrupt();(属于ThreadL类)
public class TestInterrupt { public static void main(String[] args) throws InterruptedException { Thread testThread = new TestThread(); testThread.start(); testThread.interrupt(); } /* *上面测试的三个办法都会阻塞线程,如果没有应用这个三个办法，线程会间接走完， *而且isInterrupted()为true *应用了其中一个,会抛出InterruptedException，isInterrupted()为false */ static class TestThread extends Thread { @Override public void run() { System.out.println("线程开始运行"); try { //TimeUnit.SECONDS.sleep(5); //wait(); join(); }catch (Exception e){ System.out.println("线程产生异样"+e); System.out.println(Thread.currentThread().isInterrupted()); } System.out.println("线程完结运行"); } }}- 响应中断案例
public class LockInterruptibly { static Lock firstLock = new ReentrantLock(); static Lock secondLock = new ReentrantLock(); public static void main(String[] args) { Thread firstthread = new Thread(new ThreadDemo(firstLock,secondLock)); Thread secondThread = new Thread(new ThreadDemo(secondLock,firstLock)); firstthread.start(); secondThread.start(); firstthread.interrupt(); } static class ThreadDemo implements Runnable { private Lock firstLock; private Lock secondLock; public ThreadDemo(Lock firstLock,Lock secondLock){ this.firstLock = firstLock; this.secondLock = secondLock; } //会中断处于期待的线程,开释锁，而后另一个线程获取锁,持续走 @Override public void run() { try { firstLock.lockInterruptibly(); TimeUnit.SECONDS.sleep(1); secondLock.lockInterruptibly(); }catch (Exception e){ e.printStackTrace(); }finally { firstLock.unlock(); secondLock.unlock(); System.out.println(Thread.currentThread().getName()+"失常完结"); } } }}- 不响应中断案例
public class TestSynchronized { static Object resource1 = new Object(); static Object resource2 = new Object(); public static void main(String[] args) { Thread thread1 = new TestSynchronizedThread(resource1,resource2); Thread thread2 = new TestSynchronizedThread(resource2,resource1); thread1.start(); thread2.start(); thread1.interrupt();//中断线程， } static class TestSynchronizedThread extends Thread { Object resource1; Object resource2; public TestSynchronizedThread(Object resource1,Object resource2){ this.resource1 = resource1; this.resource2 = resource2; } //即便跑出异样，也不会中断线程,两个线程持续相互期待资源，造成死锁 @Override public void run() { synchronized (resource1){ System.out.println(Thread.currentThread().getName()+"--111"); try { TimeUnit.SECONDS.sleep(1); System.out.println(Thread.currentThread().getName()+"--222"); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"--333"); } System.out.println(Thread.currentThread().getName()+"--444"); synchronized (resource2){ System.out.println(555); } } } }}4)获取锁时,限时期待
5)利用condition实现期待告诉机制,
6)condition实现阻塞队列
synchronized