JDK并发包--Condition,Semaphore,ReadWriteLock
ps:从北京到杭州可以有不同的路线,这些路线就好比多个线程,在路上可能因为各种原因停停走走,这就好比是线程的等待和通知。
Condition条件:
使用sychronized关键字来保证线程的同步时,需要wait()和notify()来保证线程间的通信;而使用重入锁时,则需要通过Condition来使线程等待和继续执行。
await(): 使当前线程等待,同时释放当前锁,当在其他线程中使用signal()或者signalAll()方法时,线程会重新获得锁并继续执行。也可响应中断跳出等待,类似于Object.wait()方法。
awaitUninterruptibly(): 与await()方法基本相同,但是它不会响应中断。
signal(): 唤醒一个等待中的进程。
signalAll():唤醒所有等待中的进程。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class LockCondition implements Runnable{ //锁的声明 public static ReentrantLock lock = new ReentrantLock(); public static Condition condition = lock.newCondition(); @Override public void run(){ try{ lock.lock(); //和object.wait()类似,在执行await()前,需要线程持有相关重入锁 condition.await(); System.out.println("Thread is going on "); }catch(InterruptedException e){ }finally{ lock.unlock(); } } public static void main(){ LockCondition t1 =new LockCondition(); Thread t = new Thread(t1); t.start(); Thread.sleep(10000); lock.lock(); //和object.notify()类似,在执行signal()前,需要线程持有相关重入锁 condition.signal(); lock.unlock(); } }
信号量(Semaphore):
允许多个线程同时访问临界区资源。
public Semaphore(int permits);//传入一个整型值,表示同时允许访问的线程数。
public Semaphore(int permits,boolean fair)//指定是否公平
信号量的主要方法有:
public void acquire();//获得一个准入许可
public void acquireUninterruptibly();获得一个准入许可,但不响应中断
public boolean tryAcquire();尝试获得许可,成功返回true,失败返回false;
public boolean tryAcquire(long timout,TimeUnit unit);在时限内尝试获得许可
public void release();线程访问资源结束后 ,释放许可
读写锁(ReadWriteLock)
读操作和写操作之间相互阻塞,写操作和写操作之间相互阻塞,读操作和读操作之间不阻塞。下例启动了18个读线程,2个写线程,可以分别使用普通锁和读写锁,可以从结果看出读写锁耗时要远远低于普通锁
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class ReadWriteLockDemo { private static Lock lock = new ReentrantLock(); private static ReentrantReadWriteLock readWriteLock =new ReentrantReadWriteLock(); private static Lock readLock = readWriteLock.readLock(); //声明读锁 private static Lock writeLock = readWriteLock.writeLock(); //声明写锁 private int value; public Object handleRead(Lock lock) throws InterruptedException { try { lock.lock(); Thread.sleep(1000); return value; }finally { lock.unlock(); } } public void handleWrite(Lock lock,int index) throws InterruptedException { try { lock.lock(); Thread.sleep(1000); value = index; }finally { lock.unlock(); } } public static void main(String[] args) { final ReadWriteLockDemo demo = new ReadWriteLockDemo(); Runnable readRunnable = new Runnable() { public void run() { try { demo.handleRead(readLock); //使用读写锁 //demo.handleRead(lock); //使用普通锁 }catch(InterruptedException e) { e.printStackTrace(); } } }; Runnable writeRunnable = new Runnable() { public void run() { try { demo.handleWrite(writeLock,new Random().nextInt()); //使用读写锁 //demo.handleRead(lock,new Random().nextInt()); //使用普通锁 }catch(InterruptedException e) { e.printStackTrace(); } } }; for(int i=0;i<18;i++) { new Thread(readRunnable).start(); } for(int i=18;i<20;i++) { new Thread(writeRunnable).start(); } } }
-----------------------------------------------------《实战Java高并发设计》笔记------------------------------------------------------