Java高并发程序设计（三）——JDK并发包（二）

引言

好久没来学习Java高并发程序设计了，感觉在慢慢遗忘之前学过的内容，今天打算重新拾起。

Condition

Condition与前两章讲的Object.wait() 和Object.notify()是很像的,基本的语法如下:

• await() 方法会使当前的线程等待,同时释放当前锁，当其他线程使用signal或者signalall方法时，当前线程会重新获得锁并继续执行。或者当线程被中断时，也能跳出等待。
• awaitUninterruptibly方法与await方法基本相同，但是他并不会在等待过程中响应中断。
  来看具体示例：

package JAVA高并发程序设计.JDK并发包;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Author:haozhixin
 * Func:  condition条件
 * Date:  20190824
 */
public class ReenterLockCondition implements Runnable {

	public static ReentrantLock reentrantLock = new ReentrantLock();
	public static Condition condition=reentrantLock.newCondition();
	@Override
	public void run() {
		try {
			reentrantLock.lock();
			condition.await();
			System.out.println("Thread is going on");
		}catch (InterruptedException e){
			e.printStackTrace();
		}finally {
			reentrantLock.unlock();
		}
	}

	public static void main(String []args) throws InterruptedException{
		ReenterLockCondition reentrantLock1 = new ReenterLockCondition();
		Thread tl = new Thread(reentrantLock1);
		tl.start();
		Thread.sleep(2000);
		//通知线程tl继续执行
		reentrantLock.lock();//必须先获得锁
		condition.signal();//启用通知
		reentrantLock.unlock();//必须释放锁
	}
}

信号量（Semaphore）

• Semaphore是一个计数信号量，它的本质是一个"共享锁"。 信号量为多线程的协作提供了更为强大的控制方法，广义上说，信号量是对锁的拓展。无论是内部锁synchronized还是重入锁ReentrantLock，一次都只允许一个线程访问一个资源，而信号量却可以指定多个线程，同时访问某一个资源。
• 信号量维护了一个信号量许可集。线程可以通过调用acquire()来获取信号量的许可；当信号量中有可用的许可时，线程能获取该许可；否则线程必须等待，直到有可用的许可为止。 线程可以通过release()来释放它所持有的信号量许可。

package JAVA高并发程序设计.JDK并发包;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * Author:haozhixin
 * Func: 信号量的使用
 * Date: 20190824
 */
public class SempleDemo  implements Runnable{
	final Semaphore semaphore = new Semaphore(5);//非公平共享锁，申请了5个许可，并且防止变化定义为final

	@Override
	public void run() {
		try {
			semaphore.acquire();//信号启动
			Thread.sleep(2000);
			System.out.print(Thread.currentThread().getId() + ":done!");
			semaphore.release();//信号量结束

		}catch (InterruptedException e){
			e.printStackTrace();
		}
	}

	public static void main(String [] args){
		ExecutorService executorService = Executors.newFixedThreadPool(20);
		final SempleDemo sempleDemo = new SempleDemo();
		for(int i=0;i<20;i++){
			executorService.submit(sempleDemo);
		}
	}
}

读写锁

读写锁可以有效的帮助减少锁竞争，提升系统性能。用锁分离的机制来提升性能非常容易理解，比如线程A1，A2，A3进行写操作，B1，B2，B3进行读操作，如果使用重入锁或者内部锁，则理论上所有操作，无论哪种组合都是串行操作。当B1读取时，B2，B3则需要等待锁。由于读操作并不对数据的完整性造成破坏，这种等待显然是不合理的。读写锁的约束可以描述如下：

• 读-读不互斥：读与读之间互不阻塞。
• 读-写互斥：读阻塞写，写也阻塞读。
• 写-写互斥：写写阻塞。

一般来说，读的操作次数远大于写操作，则读写锁可以发挥更大的功效。看一下应用案例：

package JAVA高并发程序设计.JDK并发包;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Author:haozhixin
 * Func: 读写锁场景模拟
 * Date: 20190824
 */
public class ReadWriteLockDemo {
	private static Lock lock = new ReentrantLock();
	private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
	private static Lock readLock = reentrantReadWriteLock.readLock();
	private static Lock writeLock = reentrantReadWriteLock.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() {
			@Override
			public void run() {
				try{
					demo.handleRead(readLock);
					//demo.handleRead(lock);
				}catch (InterruptedException e){
					e.printStackTrace();
				}
			}
		};
		Runnable writeRunnable = new Runnable() {
			@Override
			public void run() {
				try{
					demo.handleWrite(writeLock,new Random().nextInt());
					//demo.handleWrite(lock,new Random().nextInt());
				}catch (InterruptedException e){
					e.printStackTrace();
				}
			}
		};

		for(int i=0;i<20;i++){
			new Thread(readRunnable).start();
		}
		for(int i=0;i<2;i++){
			new Thread(writeRunnable).start();
		}

	}
}

在读操作十分耗时的时候，尽量使用读写锁分离，防止因读阻塞写入数据库。下一章我们介绍下线程池。

---

作者：select you from me
来源：CSDN
转载请联系作者获得授权并注明出处。