java中的并发:高级并发对象

目录
  1.Lock
  2.Condition
  3.优化的生产者消费者模式

1.Lock

  1.1synchronized缺陷
    线程释放锁只会有两种情况:获取锁的线程执行完了该代码块然后线程释放对锁的占有;线程执行发生异常,此时JVM会让线程自动释放锁.如果这个获取锁的线程由于要等待IO或者其他原因被阻塞了,但是又没有释放锁,其他线程便只能等待,影响程序执行效率.为此在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock.
  1.2Lock与synchronized的不同点
    1)Lock是一个类不是java语言内置的,通过这个类可以实现同步访问;synchronized是java语言的关键字,因此是内置特性.
    2)Lock必须要用户去手动释放锁,如果没有主动释放锁,就有可能导致出现死锁现象;synchronized不需要用户去手动释放锁,系统会自动让线程释放对锁的占用.
    3)Lock可以知道有没有成功获取锁,而synchronized却无法办到.
    4)Lock可以让等待锁的线程响应中断,而使用synchronized时,等待的线程会一直等待下去,不能够响应中断.
    5)Lock可以提高多个线程进行读操作的效率.并且当竞争资源非常激烈时,Lock的性能要远远优于synchronized.
  1.3Lock的使用
    1)Lock是一个接口,具有唯一实现类ReentrantLock.
    2)调用tryLock()方法可以尝试获取锁,如果获取成功则返回true,如果获取失败则返回false,返回值会立即返回.
    3)调用lock()方法用来获取锁,如果锁已被其他线程获取,则进行等待,由于在前面讲到如果采用Lock,必须主动去释放锁,因此一般使用Lock必须在try{}catch{}块中进行,并且将释放锁的操作放在finally块中以保证锁一定被被释放.

						Lock lock = ...;
						if(lock.tryLock()) {
						 try{
						  //处理任务
						}catch(Exception e){
						 
						}finally{
							 lock.unlock();   //释放锁
						} 
						}else {
						//如果不能获取锁,则直接做其他事情
						}

 

  1.4锁的特性
    1)可重入性,表明了锁的分配机制:基于线程的分配,而不是基于方法调用的分配.(synchronized和Lock都是可重入锁)
    2)可中断性,线程A正在执行锁中的代码,另一线程B正在等待获取该锁,可能由于等待时间过长,线程B不想等待了,想先处理其他事情,我们可以让它中断自己或者在别的线程中中断它,这种就是可中断锁.(synchronized不是可中断锁)
    3)公平性,公平锁即尽量以请求锁的顺序来获取锁.synchronized就是非公平锁;ReentrantLock默认情况下是非公平锁,但是可以设置为公平锁.构造函数中可以传参,如果参数为true表示为公平锁,为false为非公平锁(默认值).
  1.5ReadWriteLock文件读写锁
    维护了一对相关的锁,一个用于只读操作,另一个用于写入操作.只要没有 writer,读取锁可以由多个 reader线程同时保持,写入锁是独占的.唯一实现类ReentrantReadWriteLock,方法readLock(),writeLock().

 

2.Condition

  1)Lock替代了synchronized方法和语句的使用,Condition则替代了Object监视器方法的使用.
  2)Condition是个接口,依赖于Lock接口.生成一个Condition的基本代码是lock.newCondition().
  3)Condition为线程提供了一个含义,也可称为条件变量.当多个线程竞争同一个Lock时,通过不同的Condition可以对指定线程进行挂起或唤醒.
  4)与Object类相似,同样提供了等待和唤醒功能,而且这些方法必须在lock.lock()和lock.unlock()之间才可以使用.
    await()    wait()
    signal()   notify
    signalAll()   notifyAll()

 

3.优化的生产者消费者模式

  利用本章的Lock和Condition,代替之前的synchronized和Object,优化后的生产者消费者模式的关键代码:

				class Resource {
					private boolean flag = false;
					private int count = 0;
					private Lock lock = new ReentrantLock();
					private Condition putCon = lock.newCondition();
					private Condition getCon = lock.newCondition();

					public void put() {
						if (lock.tryLock()) {
							lock.lock();
							try {
								while (flag) {
									try {
										putCon.await();// 本方挂起
									} catch (InterruptedException e) {
									}
								}
								count++;
								System.out.println(Thread.currentThread().getName() + "生产者行为..." + count);
								flag = true;
								getCon.signal();// 唤醒对方
							} finally {
								lock.unlock();
							}
						}
					}

					public void get() {
						if (lock.tryLock()) {
							lock.lock();
							try {
								while (!flag) {
									try {
										getCon.await();// 本方挂起
									} catch (InterruptedException e) {
									}
								}
								System.out.println(Thread.currentThread().getName() + "消费者行为......" + count);
								flag = false;
								putCon.signal();// 唤醒对方
							} finally {
								lock.unlock();
							}
						}
					}
				}