并发（7）：共享受限资源（下）

痛定思痛。 2023-03-13 13:24 8阅读 0赞

### 五、临界区 ###

有时，你只是希望防止多个线程同时访问方法内部的部分代码而不是防止访问整个方法。通过这种方式分离出来的代码被称为临界区（critical section），它也使用synchronized关键字建立。这里，synchronized被用来指定某个对象，此对象的锁被用来对花括号内的代码进行同步控制：

synchronized(syncObject) {
        // 一次只能一个任务完成此代码
    }

这也被称为同步控制块；在进入此段代码前，必须得到syncObject对象的锁。如果其他线程已经得到这个锁，那么就得等到锁被释放以后，才能进入临界区。

通过使用同步控制块，而不是对整个方法进行同步控制，可以使多个任务访问对象的时间性能得到显著的提高，下面的例子比较了这两种同步控制方法。此外，它也演示了如何把一个非保护类型的类，在其他类的保护和控制之下，应用于多线程的环境：

package concurrency;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * 一对 不是线程安全的
     */
    class Pair {
    	private int x, y;
    
    	public Pair(int x, int y) {
    		this.x = x;
    		this.y = y;
    	}
    
    	public Pair() {
    		this(0, 0);
    	}
    
    	public int getX() {
    		return x;
    	}
    
    	public int getY() {
    		return y;
    	}
    
    	public void incrementX() {
    		x++;
    	}
    
    	public void incrementY() {
    		y++;
    	}
    
    	public String toString() {
    		return "x: " + x + ", y: " + y;
    	}
    
    	public class PairValuesNotEqualException extends RuntimeException {
    		public PairValuesNotEqualException() {
    			super("对值不相等: " + Pair.this);
    		}
    	}
    
    	// 检查对值是否相等
    	public void checkState() {
    		if (x != y)
    			throw new PairValuesNotEqualException();
    	}
    }
    
    /**
     * 对值管理
     */
    abstract class PairManager {
    	AtomicInteger checkCounter = new AtomicInteger(0);
    	protected Pair p = new Pair();
    	private List<Pair> storage = Collections.synchronizedList(new ArrayList<Pair>());
    
    	public synchronized Pair getPair() {
    		// 复印一份以保证原件的安全
    		return new Pair(p.getX(), p.getY());
    	}
    
    	// 假设这是一个耗时的操作
    	protected void store(Pair p) {
    		storage.add(p);
    		try {
    			TimeUnit.MILLISECONDS.sleep(50);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    	public abstract void increment();
    }
    
    /**
     * 同步整个方法
     */
    class PairManager1 extends PairManager {
    	@Override
    	public synchronized void increment() {
    		p.incrementX();
    		p.incrementY();
    		store(getPair());
    	}
    }
    
    /**
     * 使用临界区
     */
    class PairManager2 extends PairManager {
    	@Override
    	public void increment() {
    		Pair temp;
    		synchronized (this) {
    			p.incrementX();
    			p.incrementY();
    			temp = getPair();
    		}
    		store(temp);
    	}
    }
    
    /**
     * Pair操纵器
     */
    class PairManipulator implements Runnable {
    	private PairManager pm;
    
    	public PairManipulator(PairManager pm) {
    		this.pm = pm;
    	}
    
    	@Override
    	public void run() {
    		while (true)
    			pm.increment();
    	}
    
    	public String toString() {
    		return "Pair: " + pm.getPair() + " checkCounter = " + pm.checkCounter.get();
    	}
    }
    
    /**
     * 对值检验员
     */
    class PairChecker implements Runnable {
    	private PairManager pm;
    
    	public PairChecker(PairManager pm) {
    		this.pm = pm;
    	}
    
    	@Override
    	public void run() {
    		while (true) {
    			pm.checkCounter.incrementAndGet();
    			pm.getPair().checkState();
    		}
    	}
    }
    
    /**
     * 临界区
     */
    public class CriticalSection {
    	// 测试这两种不同的方法
    	static void testApproaches(PairManager pman1, PairManager pman2) {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		PairManipulator pm1 = new PairManipulator(pman1), pm2 = new PairManipulator(pman2);
    		PairChecker pcheck1 = new PairChecker(pman1), pcheck2 = new PairChecker(pman2);
    		exec.execute(pm1);
    		exec.execute(pm2);
    		exec.execute(pcheck1);
    		exec.execute(pcheck2);
    		try {
    			TimeUnit.MILLISECONDS.sleep(500);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("pm1: " + pm1 + "\npm2: " + pm2);
    		System.exit(0);
    	}
    
    	public static void main(String[] args) {
    		PairManager pman1 = new PairManager1(), pman2 = new PairManager2();
    		testApproaches(pman1, pman2);
    	}
    }

正如注释中注明的，Pair不是线程安全的，因为它的约束条件（虽然是任意的）需要两个变量要维护成相同的值。此外，如本章前面所述，自增加操作不是线程安全的，并且因为没有任何方法被标记为synchronized，所以不能保证一个Pair对象在多线程程序中不会被破坏。

你可以想象一下这种情况：某人交给你一个非线程安全的Pair类，而你需要在一个线程环境中使用它。通过创建PairManager类就可以实现这一点，PairManager类持有一个Pair对象并控制对它的一切访问。注意唯一的public方法是getPair()，它是synchronized的。对于抽象方法increment()，对increment()的同步控制将在实现的时候进行处理。

置于PairManager类的结构，它的一些功能在基类中实现，并且其一个或多个抽象方法在派生类中定义，这种结构在设计模式中称为模版方法。设计模式使你得以把变化封装在代码里；在此，发生变化的部分是模版方法increment()。在PairManager1中，整个increment()方法是被控制的；但在PairManager2中，increment()方法使用同步控制块进行同步。注意，synchronized关键字不属于方法特征签名的组成部分，所以可以在覆盖方法的时候加上去。

store()方法将一个Pair对象添加到了synchronized ArrayList中，所以这个操作是线程安全的。因此，该方法不必进行防护，可以放置在PairManager2的synchronized语句块的外部。

PairManipulator被创建用来测试两种不同类型的PairManager，其方法是在某个任务中调用increment()，而PairChecker则在另一个任务中执行。为了跟踪可以运行测试的频度，PairChecker在每次成功时都递增checkCounter。在main()中创建了两个PairManipulator对象，并允许它们运行一段时间，之后每个PairManipulator的结果会得到展示。

尽管每次运行的结果可能会非常不同，但一般来说，对于PairChecker的检查频率，PairManager1.increment()不允许有PairManager2.increment()那样多。后者采用同步控制块进行同步，所以对象不加锁的时间更长。这也是宁愿使用同步控制块而不是对整个方法进行同步控制的典型原因：使得其他线程能更多地访问（在安全的情况下尽可能多）。

你还可以使用显式的Lock对象来创建临界区：

package concurrency;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 同步整个方法
     */
    class ExplicitPairManager1 extends PairManager {
    
    	private Lock lock = new ReentrantLock();
    
    	@Override
    	public synchronized void increment() {
    		try {
    			lock.lock();
    			p.incrementX();
    			p.incrementY();
    			store(getPair());
    		} finally {
    			lock.unlock();
    		}
    	}
    }
    
    /**
     * 使用临界区
     */
    class ExplicitPairManager2 extends PairManager {
    
    	private Lock lock = new ReentrantLock();
    
    	@Override
    	public void increment() {
    		Pair temp;
    		lock.lock();
    		try {
    			p.incrementX();
    			p.incrementY();
    			temp = getPair();
    		} finally {
    			lock.unlock();
    		}
    		store(temp);
    	}
    }
    
    /**
     * 明确的关键部分
     */
    public class ExplicitCriticalSection {
    	public static void main(String[] args) {
    		PairManager pman1 = new ExplicitPairManager1(), pman2 = new ExplicitPairManager2();
    		CriticalSection.testApproaches(pman1, pman2);
    	}
    }

这里复用了CriticalSection.java的绝大部分，并创建了新的使用显式的Lock对象的PairManager类型。ExplicitPairManager2展示了如何使用Lock对象来创建临界区，而对store()的调用则在这个临界区的外部。

### 六、在其他对象上同步 ###

synchronized块必须给定一个在其上进行同步的对象，并且最合理的方式是，使用其方法正在被调用的当前对象：synchronized(this)，这正是PairManager2所使用的方式。在这种方式中，如果获得了synchronized块上的锁，那么该对象其他的synchronized方法和临界区就不能被调用了。因此，如果在this上同步，临界区的效果会直接缩小在同步的范围内。

有时必须在另一个对象同步，但是如果你这么做，就必须确保所有相关的任务都是在同一个对象上同步的。下面的示例演示了两个任务可以同时进入同一个对象，只要这个对象上的方法是在不同的锁上同步即可：

package concurrency;
    
    class DualSynch {
    	private Object syncObject = new Object();
    
    	public synchronized void f() {
    		for (int i = 0; i < 5; i++) {
    			System.out.println("f()");
    			Thread.yield();
    		}
    	}
    
    	public void g() {
    		synchronized (syncObject) {
    			for (int i = 0; i < 5; i++) {
    				System.out.println("g()");
    				Thread.yield();
    			}
    		}
    	}
    }
    
    public class SyncObject {
    	public static void main(String[] args) {
    		final DualSynch ds = new DualSynch();
    		new Thread() {
    			public void run() {
    				ds.f();
    			}
    		}.start();
    		ds.g();
    	}
    }

DualSynch.f()（通过同步整个方法）在this同步，而g()有一个在syncObject上同步的synchronized块。因此，这两个同步是互相独立的。通过在main()中创建调用f()的Thread对这一点进行了演示，因为main()线程是被用来调用g()的。从输出中可以看到，这两个方式在同时运行，因此任何一个方法都没有因为对另一个方法的同步而被阻塞。

### 七、线程本地存储 ###

防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。线程本地存储是一种自动化机制，可以为使用相同变量的每个不同的线程都创建不同的存储。因此，如果你有5个线程都要使用变量x所表示的对象，那线程本地存储就会生成5个用于x的不同的存储块。主要是，它们使得你可以将状态与线程关联起来。

创建和管理线程本地存储可以由java.lang.ThreadLocal类来实现，如下所示：

package concurrency;
    
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 访问器
     */
    class Accessor implements Runnable {
    
    	private final int id;
    
    	public Accessor(int idn) {
    		id = idn;
    	}
    
    	@Override
    	public void run() {
    		while (!Thread.currentThread().isInterrupted()) {
    			ThreadLocalVariableHolder.increment();
    			System.out.println(this);
    			Thread.yield();
    		}
    	}
    
    	public String toString() {
    		return "#" + id + ": " + ThreadLocalVariableHolder.get();
    	}
    }
    
    public class ThreadLocalVariableHolder {
    
    	private static ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
    		private Random r = new Random();
    
    		protected synchronized Integer initialValue() {
    			return r.nextInt(10000);
    		}
    	};
    
    	public static void increment() {
    		value.set(value.get() + 1);
    	}
    
    	public static int get() {
    		return value.get();
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		for (int i = 0; i < 5; i++) {
    			exec.execute(new Accessor(i));
    		}
    		TimeUnit.SECONDS.sleep(3);
    		exec.shutdownNow();
    	}
    }

ThreadLocal对象通常当作静态域存储。在创键ThreadLocal时，你只能通过get()和set()方法来访问该对象的内容，其中，get()方法将返回与其线程相关联的对象的副本，而set()会将参数插入到为其线程存储的对象中，并返回存储中原有的对象。increment()和get()方法在ThreadLocalVariableHolder中演示了这一点。注意，increment()和get()方法都不是synchronized的，因为ThreadLocal保证不会出现竞争关系。

当运行这个程序时，你可以看到每个单独的线程都被分配了自己的存储，因为它们都需要跟踪自己的计数值，即便只有一个ThreadLocalVariableHolder对象。

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