Art of Multiprocessor Programming 答案 ch8

最新推荐文章于 2015-12-12 22:39:02 发布

原创最新推荐文章于 2015-12-12 22:39:02 发布 · 2k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

本文通过具体实现探讨了多种并发控制机制，包括读写锁、优先级队列、浴室问题、房间分配及倒计时门闩等经典场景。展示了如何使用条件变量、锁及其他同步工具解决并发编程中的挑战。

93.

package p93;

import java.util.concurrent.locks.Lock;

public class SimpleRWLock
{
	private class ReadLock implements Lock
	{
		public void lock()
		{
			try
			{
				synchronized(lockObj)
				{
					while(writer)
					{
						lockObj.wait();
					}
				
					readers ++;
				}
			}catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		 
		public void unlock()
		{
			synchronized(lockObj)
			{
				if(readers <= 0)
				{
					lockObj.notifyAll();
				}
			}
		}
		
		public void lockInterruptibly() throws java.lang.InterruptedException
		{
			throw new InterruptedException();
		}
		  
		public boolean tryLock()
		{
			return false;
		}
		  
		public boolean tryLock(long arg0, java.util.concurrent.TimeUnit arg1) throws java.lang.InterruptedException
		{
			throw new InterruptedException();
		}
		  
		public java.util.concurrent.locks.Condition newCondition()
		{
			return null;
		}
	}
	
	private class WriteLock implements Lock
	{
		public void lock()
		{
			try
			{
				synchronized(lockObj)
				{
					while(readers > 0 || writer)
					{
						lockObj.wait();
					}
					
					writer =  true;
				}
			}catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		 
		public void unlock()
		{
			synchronized(lockObj)
			{
				writer = false;
				lockObj.notifyAll();
			}
		}
		
		public void lockInterruptibly() throws java.lang.InterruptedException
		{
			throw new InterruptedException();
		}
		  
		public boolean tryLock()
		{
			return false;
		}
		  
		public boolean tryLock(long arg0, java.util.concurrent.TimeUnit arg1) throws java.lang.InterruptedException
		{
			throw new InterruptedException();
		}
		  
		public java.util.concurrent.locks.Condition newCondition()
		{
			return null;
		}		
	}
	
	private int readers;
	private boolean writer;
	private Object lockObj;
	private ReadLock readLock;
	private WriteLock writeLock;
	
	public SimpleRWLock()
	{
		lockObj = new Object();
		readLock = new ReadLock();
		writeLock = new WriteLock();
	}
	
	public Lock readLock()
	{
		return readLock;
	}
	
	public Lock writeLock()
	{
		return writeLock;
	}
	
	public static void main(String[] args)
	{
		SimpleRWLock lock = new SimpleRWLock();
		
		lock.readLock().lock();
		lock.readLock().unlock();
		lock.writeLock().lock();
		lock.writeLock().unlock();
	}
}

94.

会有 readlock.lock() --> readwait > readrelease --> writelock.lock() --> write = true --> waiting for readwait == readrelease ==> deadlock

其他的线程会有 write == true ==> block

95. 不一定全部会返回，因为可能在别人的cond上死锁，boss notify自己的锁线程感应不到。比如下面的case:

package p95;


public class Prefer 
{
	private int balance;
	private int preferRequests;
	
	public static final int PREFER = 1;
	public static final int NORMAL = 2;
	
	public Prefer()
	{
		balance = 0;
		preferRequests = 0;
	}
	
	public Prefer(int initial)
	{
		this();
		balance = initial;
	}
	
	private void deposit_nolock(int k)
	{
		balance += k;
	}
	public synchronized void deposit(int k)
	{
		deposit_nolock(k);
		this.notifyAll();
	}
	
	public synchronized void withdraw(int k, int style)
	{
		try
		{
			switch(style)
			{
			case NORMAL:
				while(preferRequests > 0 || balance < k)
				{
					this.wait();
				}
				balance -= k;
				break;
			case PREFER:
				preferRequests ++;
				while(balance < k)
				{
					this.wait();
				}
				balance -= k;
				preferRequests --;
				this.notifyAll();
				break;
			default:
				throw new InterruptedException();
			}
		}catch(InterruptedException e)
		{
			this.notifyAll();
		}
	}
	
	public synchronized void transfer(Prefer other, int k)
	{
		other.withdraw(k, NORMAL);
		deposit_nolock(k);
	}
	
}

package p95;

public class TestThread extends Thread
{
	private Prefer myAccount;
	private Prefer otherAccount;
	public final int WITHDRAW = 200;
	public final int BOSS = 1000;
	
	public TestThread(Prefer me, Prefer other)
	{
		this.myAccount = me;
		this.otherAccount = other;
	}
	
	public void run()
	{
		System.out.println("To transfer ");
		myAccount.transfer(otherAccount, WITHDRAW);
		System.out.println("End of transfer ");
	}	
	
	public void boss()
	{
		myAccount.deposit(BOSS);
	}
	
	public static void main(String[] args)
	{
		Prefer[] accounts = new Prefer[2];
		for(int i = 0; i < accounts.length; i ++)
		{
			accounts[i] = new Prefer(0);
		}
		
		TestThread tester1 = new TestThread(accounts[0], accounts[1]);
		TestThread tester2 = new TestThread(accounts[1], accounts[0]);
		
		tester1.start();
		tester2.start();
		
		try
		{
			Thread.sleep(1000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println("After sleep ");
		
		tester1.boss();
		tester2.boss();
	}
}

96.

package p96;

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

public class Bathroom_1
{
	private Lock lock;
	private Condition maleCond;
	private Condition femaleCond;
	private int maleAcq;
	private int maleRel;
	private int femaleAcq;
	private int femaleRel;
	private int maleWait;
	private int femaleWait;
	
	public static final int MALE = 1;
	public static final int FEMALE = 2;
	
	public Bathroom_1()
	{
		lock = new ReentrantLock();
		maleCond = lock.newCondition();
		femaleCond = lock.newCondition();
	}
	
	public void maleEnter()
	{
		lock.lock();
		
		try
		{
			maleWait ++;
			while((femaleWait != femaleAcq && maleAcq != maleRel) 
					|| (femaleAcq != femaleRel))
			{
				maleCond.await();
			}
			
			maleAcq ++;
		}catch(Exception e)
		{
			e.printStackTrace();
			maleWait --;
			maleCond.signalAll();
			femaleCond.signalAll();
		}finally
		{
			lock.unlock();
		}
	}
	
	public void maleExit()
	{
		lock.lock();
		
		maleRel ++;
		if(maleRel == maleAcq)
		{
			femaleCond.signalAll();
		}
		
		lock.unlock();
	}
	
	public void femaleEnter()
	{
		lock.lock();
		
		try
		{
			femaleWait ++;
			while((maleWait != maleAcq && femaleAcq != femaleRel) 
					|| (maleAcq != maleRel))
			{
				femaleCond.await();
			}
			femaleAcq ++;
		}catch(Exception e)
		{
			e.printStackTrace();
			femaleWait --;
			maleCond.signalAll();
			femaleCond.signalAll();
		}finally
		{
			lock.unlock();
		}
	}
	
	public void femaleExit()
	{
		lock.lock();
		
		femaleRel ++;
		if(femaleRel == femaleAcq)
		{
			maleCond.signalAll();
		}
		
		lock.unlock();
	}
}

97.

package p97;

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

public class Rooms
{
	public interface Handler
	{
		void onEmpty();
	}
	
	private Lock lock;
	private Condition[] conds;
	private int waiting[];
	private int acquire[];
	private int release[];
	private Handler[] handlers;
	private final int m;
	private int currRoom;
	
	public Rooms(int m)
	{
		this.m = m;
		lock = new ReentrantLock();
		conds = new Condition[m + 1];
		for(int i = 0; i < conds.length; i ++)
		{
			conds[i] = lock.newCondition();
		}
		waiting = new int[m + 1];
		acquire = new int[m + 1];
		release = new int[m + 1];
		handlers = new Handler[m + 1];
		currRoom = -1;
	}
	
	private boolean toWait(int index)
	{
		if(currRoom == -1)
		{
			return false;
		}
		if(currRoom != index)
		{
			return true;
		}
		for(int i = 1; i <= m; i ++)
		{
			int other = (i + index) % (m + 1);
			if(waiting[other] != acquire[other])
			{
				return true;
			}
		}
		return false;
	}
	
	public void enter(int i)
	{
		if(i < 0 || i > m)
		{
			return;
		}
		
		lock.lock();
		
		try
		{
			waiting[i] ++;
			
			while(toWait(i))
			{
				conds[i].await();
			}
			
			acquire[i] ++;
			currRoom = i;
		}catch(Exception e)
		{
			e.printStackTrace();
		}finally
		{
			lock.unlock();
		}
	}
	
	private int notifyWho()
	{
		for(int i = 1; i <= m; i ++)
		{
			int other = (i + currRoom) % (m + 1);
			if(waiting[other] != acquire[other])
			{
				return other;
			}
		}
		
		return -1;
	}
	
	public boolean exit()
	{
		lock.lock();
		
		release[currRoom] ++;
		if(release[currRoom] == acquire[currRoom])
		{
			if(handlers[currRoom] != null)
			{
				handlers[currRoom].onEmpty();
			}
			
			int other = notifyWho();
			if(other >= 0)
			{
				conds[other].signalAll();
			}
			currRoom = -1;
		}
		
		lock.unlock();
		return true;
	}
	
	public void setExitHandler(int i, Rooms.Handler handler)
	{
		if(i < 0 || i > m)
		{
			return;
		}
		
		lock.lock();
		handlers[i] = handler;
		lock.unlock();
	}
}

98.

package p98;

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


public class CountDownLatch 
{
	private Lock lock;
	private Condition cond;
	private int m;
	
	public CountDownLatch(int m)
	{
		this.m = m;
		lock = new ReentrantLock();
		cond = lock.newCondition();
	}
	
	public void countDown()
	{
		lock.lock();
		m --;
		if(m <= 0)
		{
			cond.signalAll();
		}
		lock.unlock();
	}
	
	public void await()
	{
		lock.lock();
		
		try
		{
			while(m > 0)
			{
				cond.await();
			}
		}catch(Exception e)
		{
			e.printStackTrace();
		}finally
		{
			lock.unlock();
		}
	}
	
	/*
	 * Lock is not necessary as:
	 * 1.	set m at anytime can get matching history
	 * 2.	User should take care of reset since I don't want to block reset() method
	 */
	public void reset(int m)
	{
		lock.lock();
		this.m = m;
		lock.unlock();
	}
}

标签