Art of Multiprocessor Programming 答案 ch17

最新推荐文章于 2015-05-06 11:58:46 发布

fulltopic

最新推荐文章于 2015-05-06 11:58:46 发布

阅读量1.2k

点赞数

文章标签：多核无锁

本文链接：https://blog.csdn.net/fulltopic/article/details/39482653

版权

本文讨论了多核编程中关于线程同步的问题，分析了在特定情况下线程行为不确定性和同步算法的正确性。通过举例说明了树形结构在同步过程中的缺陷，以及如何通过归纳法证明线程同步的轮数。同时，提到了不同类型的树在并发操作中的性能表现，如组合树、静态树和分发树。

摘要由CSDN通过智能技术生成

198. 如果线程 k + 2^r 比线程 k 快很多，当线程 k + 2^r 读 a[k]的时候将读到没有 sum k段的原始值，没有求和的作用。

public void run() {
 int d = 1, sum = 0;
 while (d < N) {
  if (i >= d)
    sum = a[i-d];
  b.await(); 
  if (i >= d)
   a[i] += sum;
  b.await();
  d = d * 2;
}}}

代码来自书作者ppt。

199.

package p199;

import java.util.concurrent.atomic.AtomicInteger;

public class SenseBarrier 
{
	private AtomicInteger count;
	private final int size;
	private boolean sense;
	private ThreadLocal
   
   
    
     threadSense;
	
	public SenseBarrier(int n)
	{
		count = new AtomicInteger(n);
		size = n;
		sense = false;
		threadSense = new ThreadLocal
    
    
     
     ()
				{
					protected Boolean initialValue() { return !sense; };
				};
	}
	
	public void await()
	{
		boolean mySense = threadSense.get();
		int position = count.getAndDecrement();
		
		if(position == 1)
		{
			count.set(size);
			sense = mySense;
			
			this.notifyAll();
		}else
		{
			while(sense != mySense)
			{
				try
				{
					this.wait();
				}catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		}
		
		threadSense.set(!mySense);
	}

}

当参与的线程行为不确定性强，响应时间要求不高，cpu不希望独占是采用wait的方式合适；否则采用spin比较合适。

200.

package ch17.basic;

import java.util.concurrent.atomic.AtomicInteger;

public abstract class TreeNode 
{
	protected AtomicInteger count;
	protected TreeNode parent;
	protected volatile boolean sense;
	protected final int radix;
	
	public TreeNode(int radix)
	{
		sense = false;
		parent = null;
		this.radix = radix;
		count = new AtomicInteger(radix);
	}
	
	public TreeNode(int radix, TreeNode parent)
	{
		this(radix);
		this.parent = parent;
	}
	
	public void nodeNotify()
	{
		return;
	}
	
	abstract public void await();
	
	abstract public void build(int depth, Integer leaves, TreeNode leaf[]);
	
}

package ch17.p200;

import ch17.basic.Barrier;
import ch17.basic.TreeNode;

public class RunnableTree implements Barrier 
{
	final int radix;
	Node[] leaf;
	int leaves;
	ThreadLocal
   
   
    
     threadSense;
	ThreadLocal
    
    
     
      ThreadID;
	Runnable task;
	
	final int n;
	
	public RunnableTree(int n, int radix, Runnable task)
	{
		this.radix = radix;
		this.n = n;
		leaves = 0;
		
		threadSense = new ThreadLocal
     
     
      
      ()
				{
					protected Boolean initialValue() { return true; };
				};
		ThreadID = new ThreadLocal
      
      
       
       ()
				{
					protected Integer initialValue() { return 0; };
				};
		
		this.task = task;
		
		build();
	}
	
	public void await()
	{
		int me = ThreadID.get();
		Node myNode = leaf[me / radix];
		myNode.await();
	}
	
	private void build()
	{
		leaf = new Node[n / radix];
		
		int depth = 0;
		int layNum = n;
		while(layNum > 1)
		{
			depth ++;
			layNum = layNum / radix;
		}
		
		Node root = new Node(radix);
		Integer leaveNum = new Integer(0);
		root.build(depth, leaveNum, leaf);
		leaves = leaveNum;
	}
	
	
	
	private