重入锁和读写锁

逃离我推掉我的手 2023-06-16 04:59 1阅读 0赞

在java多线程中，我们知道可以用synchronize关键字来实现线程间的同步互斥工作，还有更加优秀的机制去实现同步互斥工作，Lock对象。重入锁和读写锁，他们具有比synchronize更加强大的功能，并且具有嗅探锁定，多路分支等功能。  
 一、ReentrantLock（重入锁）（详见JDK-API）

public class UseReentrantLock { 
    	
    	private Lock lock = new ReentrantLock();
    	
    	public void method1(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
    			Thread.sleep(1000);
    			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		} finally { 
    			
    			lock.unlock();
    		}
    	}
    	
    	public void method2(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
    			Thread.sleep(2000);
    			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		} finally { 
    			
    			lock.unlock();
    		}
    	}
    	
    	public static void main(String[] args) { 
    
    		final UseReentrantLock ur = new UseReentrantLock();
    		Thread t1 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				ur.method1();
    				ur.method2();
    			}
    		}, "t1");
    
    		t1.start();
    		try { 
    			Thread.sleep(10);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		//System.out.println(ur.lock.getQueueLength());
    	}
    }

二、锁的等待与通知  
   在使用synchronize的时候，如果需要多线程之间进行协作工作，则需要Object的wait（）和notify（）,notifyAll( )方法进行配合工作。那么同样，我们在使用Lock的时候，可以使用一个新的等待通知类，它就是Condition，这个Condition一定是针对具体某一把锁的。也就是在只有锁的基础上才会产生Condition。

public class UseCondition { 
    
    	private Lock lock = new ReentrantLock();
    	private Condition condition = lock.newCondition();
    	
    	public void method1(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
    			Thread.sleep(3000);
    			System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
    			condition.await();	// Object wait
    			System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public void method2(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
    			Thread.sleep(3000);
    			System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
    			condition.signal();		//Object notify
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public static void main(String[] args) { 
    		
    		final UseCondition uc = new UseCondition();
    		Thread t1 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				uc.method1();
    			}
    		}, "t1");
    		Thread t2 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				uc.method2();
    			}
    		}, "t2");
    		t1.start();
    
    		t2.start();
    	}
    	
    }

三、多Condition  
   我们可以通过一个Lock对象产生多个Condition进行多线程间的交互，非常的灵活。可以使得部分需要唤醒的线程唤醒，其他线程则继续等待通知。

public class UseManyCondition { 
    
    	private ReentrantLock lock = new ReentrantLock();
    	private Condition c1 = lock.newCondition();
    	private Condition c2 = lock.newCondition();
    	
    	public void m1(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
    			c1.await();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public void m2(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
    			c1.await();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public void m3(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
    			c2.await();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public void m4(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
    			c1.signalAll();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public void m5(){ 
    		try { 
    			lock.lock();
    			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
    			c2.signal();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			lock.unlock();
    		}
    	}
    	
    	public static void main(String[] args) { 
    		
    		
    		final UseManyCondition umc = new UseManyCondition();
    		Thread t1 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				umc.m1();
    			}
    		},"t1");
    		Thread t2 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				umc.m2();
    			}
    		},"t2");
    		Thread t3 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				umc.m3();
    			}
    		},"t3");
    		Thread t4 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				umc.m4();
    			}
    		},"t4");
    		Thread t5 = new Thread(new Runnable() { 
    			@Override
    			public void run() { 
    				umc.m5();
    			}
    		},"t5");
    		
    		t1.start();	// c1
    		t2.start();	// c1
    		t3.start();	// c2
    		
    
    		try { 
    			Thread.sleep(2000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    
    		t4.start();	// c1
    		try { 
    			Thread.sleep(2000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		t5.start();	// c2
    		
    	}

四 . Lock / Condition其他方法和用法  
    1.公平锁和非公平锁: Lock lock = new ReentrantLock ( boolean isFair);  
   lock的用法:  
     tryLock():尝试获得锁,获得结果用true/false返回.  
      tryLock():在给定的时间内尝试获得锁,获得结果用true/false返回.  
      isFair():是否是公平锁  
      isLocked():是否锁定  
      getHoldCount():查询当前线程保持此锁的个数,也就是调用lock()的次数  
      lockInterruptibly:优先响应中断的锁