并发（22）：性能调优（下）

旧城等待， 2023-03-04 05:25 10阅读 0赞

### 三、乐观加锁 ###

尽管Atomic对象将执行像decrementAndGet()这样的原子性操作，但是某些Atomic类还允许你执行所谓的“乐观加锁”。这意味着当你执行某项计算时，实际上没有使用互斥，但是在这项计算完成，并且你准备更新这个Atomic对象时，你需要使用一个称为compareAndSet()的方法。你将旧值和新值一起提交给这个方法，如果旧值与它在Atomic对象中发现的值不一致，那么这个操作就失败——这意味着某个其他任务已经于此操作执行期间修改了这个对象。记住，我们在正常情况下将使用互斥（synchronized或Lock）来防止多个任务同时修改一个对象，但是这里我们是“乐观的”，因为我们保持数据为未锁定状态，并希望没有任何其他任务插入修改它。所有这些又都是以性能的名义执行的——通过使用Atomic来替代synchronized或Lock，可以获得性能上的好处。

如果compareAndSet()操作失败会发生什么？这正是棘手的地方，也是你应用这项技术时的受限之处，即只能针对能够吻合这些需求的问题。如果compareAndSet()失败，那么就必须决定做些什么，这是一个非常重要的问题，因为如果不能执行某些恢复操作，那么你就不能使用这项技术，从而必须使用传统的互斥。你可能会重试这个操作，如果在第二次成功，那么万事大吉；或者可能会忽略这次失败，直接结束——在某些仿真中，如果数据点丢失，在重要的框架中，这就是最终需要做的事情（当然，你必须很好地理解你的模型，以了解情况是否确实如此）。

考虑一个假象的仿真，它由长度为30的100000个基因构成，这可能是某种类型的遗传算法的起源。假设伴随着遗传算法的每次“进化”，都会发生某些代价高昂的计算，因此你决定使用一台多处理器机器来分布这些任务以提高性能。另外，你将使用Atomic对象而不是Lock对象来防止互斥开销（当然，一开始，你使用synchronized关键字以最简单的方式编写了代码。一旦你运行该程序，发现它太慢了，并开始应用性能调优技术，而此时你也只能写出这样的解决方案）。因为你的模型的特性，使得如果在计算过程中产生冲突，那么发现冲突的任务将直接忽略它，并不会更新它的值。下面是这个示例的代码：

package concurrency;
    
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class FastSimulation {
    	static final int N_ELEMENTS = 100000;
    	static final int N_GENES = 30;
    	static final int N_EVOLVERS = 50;
    	static final AtomicInteger[][] GRID = new AtomicInteger[100000][N_GENES];
    	static Random r = new Random();
    
    	/**
    	 * 进化
    	 */
    	static class Evolver implements Runnable {
    		@Override
    		public void run() {
    			while (!Thread.interrupted()) {
    				// 随机选择要处理的元素
    				int element = r.nextInt(N_ELEMENTS);
    				for (int i = 0; i < N_GENES; i++) {
    					int previous = element - 1;
    					if (previous < 0)
    						previous = N_ELEMENTS - 1;
    					int next = element + 1;
    					if (next >= N_ELEMENTS)
    						next = 0;
    					int oldvalue = GRID[element][i].get();
    					// 执行某种建模计算
    					int newvalue = oldvalue + GRID[previous][i].get() + GRID[next][i].get();
    					newvalue /= 3;// 取这三个值的平均值
    					if (!GRID[element][i].compareAndSet(oldvalue, newvalue)) {
    						// 这里的政策是用来处理失败的，而这里，我们只是报告失败，然后忽略它;我们的模型最终会处理它
    						System.out.println("Old value changed from " + oldvalue);
    					}
    				}
    			}
    		}
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		for (int i = 0; i < N_ELEMENTS; i++)
    			for (int j = 0; j < N_GENES; j++)
    				GRID[i][j] = new AtomicInteger(r.nextInt(1000));
    		for (int i = 0; i < N_EVOLVERS; i++)
    			exec.execute(new Evolver());
    		TimeUnit.SECONDS.sleep(5);
    		exec.shutdownNow();
    	}
    }

所有元素都被置于数组内，这被认为有助于提高性能（这个假设将在一个练习中进行测试）。每个Evolver对象会用它前一个元素和后一个元素来平均它的值，如果在更新时失败，那么将直接打印这个值并继续执行。注意，在这个程序中没有出现任何互斥。

### 四、ReadWriteLock ###

ReadWriteLock对向数据结构相对不频繁的写入，但是有多个任务经常读取这个数据结构的这类情况进行了优化。ReadWriteLock使得你可以同时有多个读取者，只要它们都不试图写入即可。如果写锁已经被其他任务持有，那么任何读取者都不能访问，直至这个写锁被释放为止。

ReadWriteLock是否能够提高程序的性能是完全不可确定的，它取决于诸如数据被读取的频率与被修改的频率相比较的结果，读取和写入操作的时间（锁将更复杂，因此短操作并不能带来好处），有多少线程竞争以及是否在多处理机器上运行等因素。最终，唯一可以了解ReadWriteLock是否能够给你的程序带来好处的方式就是用试验来证明：

下面是只展示了ReadWriteLock的最基本用法的示例：

package concurrency;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class ReaderWriterList<T> {
    	private ArrayList<T> lockedList;
    	// Make the ordering fair
    	private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    
    	public ReaderWriterList(int size, T initialValue) {
    		lockedList = new ArrayList<T>(Collections.nCopies(size, initialValue));
    	}
    
    	public T set(int index, T element) {
    		Lock wlock = lock.writeLock();
    		wlock.lock();
    		try {
    			return lockedList.set(index, element);
    		} finally {
    			wlock.unlock();
    		}
    	}
    
    	public T get(int index) {
    		Lock rlock = lock.readLock();
    		rlock.lock();
    		try {
    			if (lock.getReadLockCount() > 1)
    				System.out.println(lock.getReadLockCount());
    			return lockedList.get(index);
    		} finally {
    			rlock.unlock();
    		}
    	}
    
    	public static void main(String[] args) {
    		new ReaderWriterListTest(30, 1);
    	}
    }
    
    class ReaderWriterListTest {
    	ExecutorService exec = Executors.newCachedThreadPool();
    	private final static int SIZE = 100;
    	private static Random r = new Random();
    	private ReaderWriterList<Integer> list = new ReaderWriterList<Integer>(SIZE, 0);
    
    	private class Writer implements Runnable {
    		@Override
    		public void run() {
    			try {
    				for (int i = 0; i < 20; i++) { // 2 second test
    					list.set(i, r.nextInt());
    					TimeUnit.MILLISECONDS.sleep(100);
    				}
    			} catch (InterruptedException e) {
    				// 可接受的退出方式
    			}
    			System.out.println("Writer finished, shutting down");
    			exec.shutdownNow();
    		}
    	}
    
    	private class Reader implements Runnable {
    		@Override
    		public void run() {
    			try {
    				while (!Thread.interrupted()) {
    					for (int i = 0; i < SIZE; i++) {
    						list.get(i);
    						TimeUnit.MILLISECONDS.sleep(1);
    					}
    				}
    			} catch (InterruptedException e) {
    				// 可接受的退出方式
    			}
    		}
    	}
    
    	public ReaderWriterListTest(int readers, int writers) {
    		for (int i = 0; i < readers; i++)
    			exec.execute(new Reader());
    		for (int i = 0; i < writers; i++)
    			exec.execute(new Writer());
    	}
    }

ReaderWriterList可以持有固定数量的任何类型的对象。你必须向构造器提供所希望的列表尺寸和组装这个列表时所用的初始对象。set()方法要获取一个写锁。以调用底层的ArrayList.set()，而get()方法要获取一个读锁，以调用底层的ArrayList.get()。另外，get()将检查是否已经有多个读取者获取了读锁，如果是，则将显示这种读取者的数量，以证明可以有多个读取者获得读锁。

为了测试ReaderWriterList，ReaderWriterListTest为ReaderWriterList<Integer>创建了读取者和写入者。注意，写入者的数量远少于读取者。

如果你在JDK文档中查看ReentrantReadWriteLock，就会发现还有大量的其他方法可用，涉及“公平性”和“政策性决策”等问题。这是一个相当复杂的工具，只有当你在搜索可以提高性能的方法时，才应该想到用它。你的程序的第一个草案应该使用更直观的同步，并且只有在必需时在引入ReadWriteLock。

**如果本文对您有很大的帮助，还请点赞关注一下。**