亲宝软件园·资讯

展开

并发系列64章(并行编程二)第六章

时空道人 人气:0

前言

续前一章。

1.并行调用

2.动态并行

3.并行linq

并行调用

指的是调用一批方法,并且这些方法是(大部分)相互独立的。

static void ProcessArray(double[] array)
{
	Parallel.Invoke(
		() => { ProcessPartialArray(array, 0, array.Length / 2); },
		() => { ProcessPartialArray(array, array.Length / 2, array.Length); }
		);
}

static void ProcessPartialArray(double[] array, int begin,int end)
{
	// 开始计算
}

当然我们不知道到底有多少方法需要并行的时候,可以这样:

static void DoActionTimes(CancellationToken token, params Action[] action)
{
	Parallel.Invoke(new ParallelOptions { CancellationToken=token} ,action);
}

之所以填写一个token进来,是希望有一个可以取消的状态。

动态并行

上面的并行调用中,解决了一个问题,就是在确定要并行的数量的时候,我们通过传入一个action数组,来实现。

但是呢,有时候我们不确定到底我们多少并行数量。上文中,我们action是一个数组已经确定了数量了,因为数组可以简单的遍历,通过下标就可以得到每一个并行委托。

有些却不能,如链表,树,图等,复制一些的数据,需要遍历计算的时候,就是在运行的时候才知道数量级是多少,所以又叫动态并行。

public class Node
{
	public Node left;
	public Node right;
}

static void Travrese(Node current)
{
	// 对current 做一些操作
	if (current.left!=null)
	{
		Task.Factory.StartNew(() => Travrese(current.left),
			CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
	}

	if (current.right != null)
	{
		Task.Factory.StartNew(() => Travrese(current.right),
			CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
	}
}

static void ProcessTree(double[] array)
{
	Node root = new Node();
	var task= Task.Factory.StartNew(() => Travrese(root),
			CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
	task.Wait();
}

关键部分,在TaskCreationOptions.AttachedToParent;

//
// 摘要:
//     指定将任务附加到任务层次结构中的某个父级。 默认情况下,子任务(即由外部任务创建的内部任务)将独立于其父任务执行。 可以使用 System.Threading.Tasks.TaskContinuationOptions.AttachedToParent
//     选项以便将父任务和子任务同步。 请注意,如果使用 System.Threading.Tasks.TaskCreationOptions.DenyChildAttach
//     选项配置父任务,则子任务中的 System.Threading.Tasks.TaskCreationOptions.AttachedToParent 选项不起作用,并且子任务将作为分离的子任务执行。
//     有关详细信息,请参阅附加和分离的子任务。

这种情况是父任务和子任务。

在此解释一下,task.wait() 因为父任务和子任务同步了,所以说这个await是等待了所以任务完成后,这里的并行是子任务是并行的,当然不能完全这么说,父父子子,子又是父,大概就是这个意思哈。

如果没有子任务等待你可以这样:

var task= Task.Factory.StartNew(() => { },
		CancellationToken.None, TaskCreationOptions. None, TaskScheduler.Default);

task.ContinueWith(t => Trace.WriteLine("Task is dome"),
	CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default
	);

上面的code不是并行的范畴,而是异步编程的范畴了。

当然,上面的动态并行也可以这样写。

if (current.left!=null)
{
   var leftTask=Task.Factory.StartNew(() => Travrese(current.left),
		CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
}

if (current.right != null)
{
   var rightTask=Task.Factory.StartNew(() => Travrese(current.right),
		CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
}
Task.WaitAll(leftTask, rightTask);

当然了,上面肯定会报错,因为leftTask, rightTask拿不到。由此我们可见通过建立父子任务,这样在做一些判断的时候 current.right != null

来决定是否创建task的时候,waitall显得笨重,因为它必须确定task的数量。

并行linq

这个就是希望我们可以使用linq了,linq不仅仅是为了使我们的代码方便,而是一种编程思想,还很多好处,这里就不列举了,百度很多。

static IEnumerable<int> MultiplyBy2(IEnumerable<int> values)
{
	return values.AsParallel().Select(item => item * 2);
}

这样是没有顺序的。

return values.AsParallel().AsOrdered().Select(item => item * 2);

这样是有顺序的,试想一下,如果让我们去实现并行后IEnumerable 按照原来的顺序,是不是非常麻烦。

总之,能使用linq就用linq吧。

下一章

整理了基础的数据流。

加载全部内容

相关教程
猜你喜欢
用户评论