互聯網 - 大數據

“為什么很多看起來不是很復雜的網站，比如 Facebook 需要大量頂尖高手來開發？”
參看網址：https://www.zhihu.com/question/20303645

工匠們喜歡不斷雕琢自己的產品，不斷改善自己的工藝，享受著產品在雙手中升華的過程。工匠們對細節有很高要求，追求完美和極致，對精品有著執著的堅持和追求，把品質從99%提高到99.99%，其利雖微，卻長久造福于世。

原文地址：http://rerun.me/2014/10/21/akka-notes-actor-lifecycle-basic/

 public static class Utilities
{
public static bool IsInLandscape(this PhoneApplicationPage page)
{
return !page.IsInPortrait();
}
public static bool IsInPortrait(this PhoneApplicationPage page)
{
return page.IsInOrientation(PageOrientation.Portrait |
PageOrientation.PortraitUp | PageOrientation.PortraitDown);
}
public static bool IsInOrientation(this PhoneApplicationPage page, PageOrientation testOrientation)
{
var orientation = page.Orientation;
return orientation.IsOrientation(testOrientation);
}
public static bool IsOrientation(this PageOrientation orientation, PageOrientation testOrientation)
{
return (orientation & testOrientation) > 0;
}
}

2. 其中1中的最上方一個窗口為boa-constructor的工具條，里面有基本的一些控件等。見下圖：

 1 # -*- coding: gb2312 -*-
 2 
 3 #Boa:Frame:Frame1
 4 
 5 
 6 
 7 import wx
 8 
 9 
 10 
 11 def create(parent):
 12 
 13 return Frame1(parent)
 14 
 15 
 16 
 17 [wxID_FRAME1, wxID_FRAME1BUTTON1, wxID_FRAME1LABEL1,
 18 
 19 ] = [wx.NewId() for _init_ctrls in range(3)]
 20 
 21 
 22 
 23 class Frame1(wx.Frame):
 24 
 25 def _init_ctrls(self, prnt):
 26 
 27 # generated method, don't edit
 28 
 29 wx.Frame.__init__(self, id=wxID_FRAME1, name='', parent=prnt,
 30 
 31 pos=wx.Point(426, 280), size=wx.Size(400, 250),
 32 
 33 style=wx.DEFAULT_FRAME_STYLE,
 34 
 35 title=u'\u6211\u7684\u7b2c\u4e00\u4e2aWxPython\u7a0b\u5e8f')
 36 
 37 self.SetClientSize(wx.Size(384, 212))
 38 
 39 
 40 
 41 self.Label1 = wx.StaticText(id=wxID_FRAME1LABEL1,
 42 
 43 label=u'\u6211\u559c\u6b22BOA', name=u'Label1', parent=self,
 44 
 45 pos=wx.Point(64, 24), size=wx.Size(97, 25), style=0)
 46 
 47 self.Label1.SetBackgroundColour(wx.Colour(228, 252, 230))
 48 
 49 self.Label1.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL, False,
 50 
 51 u'\u5fae\u8f6f\u96c5\u9ed1'))
 52 
 53 
 54 
 55 self.button1 = wx.Button(id=wxID_FRAME1BUTTON1,
 56 
 57 label=u'\u70b9\u51fb\u6309\u94ae', name='button1', parent=self,
 58 
 59 pos=wx.Point(192, 24), size=wx.Size(75, 24), style=0)
 60 
 61  self.button1.Bind(wx.EVT_BUTTON, self.OnButton1Button,
 62 
 63 id=wxID_FRAME1BUTTON1)
 64 
 65 
 66 
 67 def __init__(self, parent):
 68 
 69  self._init_ctrls(parent)
 70 
 71 
 72 
 73 def OnButton1Button(self, event):
 74 
 75 
 76 
 77 fileDlg = wx.FileDialog(self,u'FileDialog',u'choose file')
 78 
 79 re = fileDlg.ShowModal()
 80 
 81 if re==5100:
 82 
 83 sr= fileDlg.GetFilename()
 84 
 85 print sr
 86 
 87  self.ShowDlg(sr)
 88 
 89 #todo:
 90 
 91  event.Skip()
 92 
 93 
 94 
 95 def ShowDlg(self,content=""):
 96 
 97 dlg = wx.MessageDialog(self,content,
 98 
 99 '確認框',
100 
101 wx.OK | wx.ICON_INFORMATION
102 
103  )
104 
105 dlg.ShowModal()

　　在多核CPU在今天和不久的將來，計算機將擁有更多的內核，Microsoft為了利用這個硬件特性，于是在Visual Studio 2010 和 .NET Framework 4的發布及以上版本中，添加了并行編程這個新特性，我想它以后勢必會改變我們的開發方式。

　　在以前或者說現在，我們在并行開發的時候可能會想到利用多線程和鎖技術來做，充分利用多CPU的特性，但是當我們了解并掌握了并行編程技術之后，我們可以不必擔心在多線程中的資源死鎖和繁瑣的DEBUG查找等低級操作。新的并行編程簡單了并行開發，使我們可以用新的方法來編程并行運算的代碼，從而不必直接去處理線程或者線程池。下圖從較高層面上概述了 .NET Framework 4 中的并行編程體系結構。

　　園子里已經有很多關于LINQ的博客（如一線碼農的《8天玩轉并行開發》系列，非常感謝這些分享的人。:）），本來是不想再寫的，但是想了一下還是寫一下吧，算是作為自己的學習筆記了。

　　下面為并行編程所用到的數據，摘自MSDN。

.Net framework并行編程相關為我們提供了一個新的命名空間：System.Threading.Tasks。

	類	說明
	Parallel	提供對并行循環和區域的支持。
	ParallelLoopState	可用來使 Parallel 循環的迭代與其他迭代交互。此類的實例由 Parallel 類提供給每個循環；不能在您的用戶代碼中創建實例。
	ParallelOptions	存儲用于配置 Parallel 類的方法的操作的選項。
	Task	表示一個異步操作。
	Task<TResult>	表示一個可以返回值的異步操作。
	TaskCanceledException	表示一個用于告知任務取消的異常。
	TaskCompletionSource<TResult>	表示未綁定到委托的 Task<TResult> 的制造者方，并通過 Task 屬性提供對使用者方的訪問。
	TaskExtensions	提供一組用于處理特定類型的 Task 實例的靜態方法（在 Visual Basic 中為共享方法）。
	TaskFactory	提供對創建和計劃 Task 對象的支持。
	TaskFactory<TResult>	提供對創建和計劃 Task<TResult> 對象的支持。
	TaskScheduler	表示一個處理將任務排隊到線程中的低級工作的對象。
	TaskSchedulerException	表示一個用于告知由 TaskScheduler 計劃的某個操作無效的異常。
	UnobservedTaskExceptionEventArgs	為在出錯的 Task 的異常未觀察到時引發的事件提供數據。

首先介紹一下并行編程為我們提供的拓展方法

System.Linq.ParallelEnumerable 類為LINQ所能查詢的集合IEnumerable提供了拓展方法，讓我們更加容易的使用并行查詢。如下：

static void Main(string[] args)
{
Random random = new Random();
List<int> intList = new List<int>();
for (int i = 0; i < 100; i++)
{
intList.Add(random.Next(100));
}
//查詢大于50的數
var queryResult = from varable in intList.AsParallel()
where varable > 50
select varable;
queryResult.ForAll<int>(tmp => Console.WriteLine(tmp));
}

默認PLINQ使用主機上的所有處理器，若要指定并行處理的最大任務數，可以用拓展方法WithDegreeOfParallelism(int degreeOfParallelism)，其中degreeOfParallelism為設置的最大任務數量。degreeOfParallelism默認為CPU的核心數，如果CPU多余64核，而沒有手動指定，則為64。

　　有必要提一下上面用到的ForAll運算符，在普通的LINQ查詢中，執行被延遲到Foreach循環中，或通過調用方法ToList()，ToArray()等。在 PLINQ 中，還可以使用 foreach 執行查詢和循環訪問結果。但是，foreach 本身不會并行運行，因此，它需要將所有并行任務的輸出合并回到該循環正在其上運行的線程中。在 PLINQ 中，當必須保留查詢結果的最終排序時，以順序方式處理結果時，以及例如當為每個語句調用 Console.WriteLine 時，必須使用 foreach。為了使不需要保留排序時以及結果的處理可自己并行化時更快地執行查詢，請使用 ForAll<TSource> 方法來執行 PLINQ 查詢。ForAll<TSource> 不執行此最終合并步驟。

PLINQ為我們的查詢進行了加速，在編寫PLINQ查詢需要注意的事項。影響PLINQ查詢的因素有下面這些：

1.總體工作的計算開銷。

為了實現加速，PLINQ 查詢必須具有足夠的適合并行工作來彌補開銷。工作可表示為每個委托的計算開銷與源集合中元素數量的乘積。假定某個操作可并行化，則它的計算開銷越高，加速的可能性就越大。例如，如果某個函數執行花費的時間為 1 毫秒，則針對 1000 個元素進行的順序查詢將花費 1 秒來執行該操作，而在四核計算機上進行的并行查詢可能只花費 250 毫秒。這樣就產生了 750 毫秒的加速。如果該函數對于每個元素需要花費 1 秒來執行，則加速將為 750 秒。如果委托的開銷很大，則對于源集合中的很少幾個項，PLINQ 可能會提供明顯的加速。相反，包含無關緊要委托的小型源集合通常不適合于 PLINQ。

在下面的示例中，queryA 可能適合于 PLINQ（假定其 Select 函數涉及大量工作）。queryB 可能不適合，原因是 Select 語句中沒有足夠的工作，并且并行化的開銷將抵銷大部分或全部加速。

var queryA = from num in numberList.AsParallel()
select ExpensiveFunction(num); //good for PLINQ
var queryB = from num in numberList.AsParallel()
where num % 2 > 0
select num; //not as good for PLINQ

總而言之，就是當我們的Select函數有很少的時候，就不要用PLINQ查詢了。

2.系統上的邏輯內核數（并行度）。

適合并行的查詢在具有更多內核的計算機上運行更快，原因是可以在更多并行線程之間分擔工作。加速的總量取決于查詢的總體工作中可并行化的百分比。但是，請不要假定所有查詢在八核計算機上的運行速度都比在四核計算機的運行速度快兩倍。在調整查詢以實現最佳性能時，衡量具有多個內核的計算機上的實際結果十分重要。這一點與第一點相關：更大的數據集需要消耗更多的計算資源。

3.操作的數量和種類。

對于必須要保持元素在源序列中的順序的情況，PLINQ 提供了 AsOrdered 運算符。排序會產生開銷，但此開銷通常是適度的。GroupBy 和 Join 操作同樣也會產生開銷。如果允許按任意順序處理源集合中的元素，并在這些元素就緒時立即將它們傳遞到下一個運算符，則 PLINQ 的性能最佳。

4.查詢的執行形式。

如果要通過調用 ToArray 或 ToList 存儲查詢的結果，則必須將來自所有并行線程的結果合并為單個數據結構。這會涉及到不可避免的計算開銷。同樣，如果您使用 foreach循環對結果進行迭代，則需要將來自工作線程的結果序列化到枚舉器線程上。但是，如果只需要基于來自每個線程的結果執行某個操作，您可以使用 ForAll 方法在多個線程上執行此工作。

5.合并選項的類型。

可將 PLINQ 配置為將其輸出放入緩沖區，并以區塊方式或在整個結果集完成后同時生成輸出，或者在個別結果生成時流式傳送這些結果。前者可縮短總體執行時間，而后者可縮短生成的元素之間的延遲。盡管合并選項并不總是對總體查詢性能有很大影響，但是，由于它們控制用戶必須等待多長時間才能看到結果，因此可能會對感覺到的性能產生影響。

6.分區的種類。

在某些情況下，針對可建立索引的源集合進行的 PLINQ 查詢可能會產生不平衡的工作負載。如果發生這種情況，您也許能夠通過創建自定義分區程序來提高查詢性能。

下一節，將寫一下PLINQ中的分區和自定義分區。

　　最近因為比較忙，好久沒有寫博客了，這篇主要給大家分享一下PLINQ中的分區。上一篇介紹了并行編程，這邊詳細介紹一下并行編程中的分區和自定義分區。

　　先做個假設，假設我們有一個200Mb的文本文件需要讀取，怎么樣才能做到最優的速度呢？對，很顯然就是拆分，把文本文件拆分成很多個小文件，充分利用我們計算機中的多核cpu的優勢，讓每個cpu都充分的利用，達到效率的最大化。然而在PLINQ中也是，我們有一個數據源，如果想進行最大的并行化操作，那么就需要把其拆分為可以多個線程同時訪問的多個部分，這就是PLINQ中的分區。當然，微軟已經為我們想到了這一點，知道他的用戶可能會有這個需求，所以就先說一下微軟給我們提供的默認的一個分區程序吧。

　　微軟提供的默認的分區程序又叫做任務并行庫（TPL），其實就是當你用PLINQ的ForEach的時候，默認在其內部就會給我們進行分區。怎么樣，是不是很方便。不過有時候，你可能會需要自己來進行拆分，那么就是另外一種跟高級一點的用法了，就是PLINQ的自定義分區。自定義分區有兩種，一種是按照范圍分區，另一種是按照區塊分區。其中按照范圍分區在針對鏈表集合能夠提供非常好的性能，比如IList等，不過它也有一點缺點那就是如果一個線程提前完成，它將無法幫助其他線程完成它們的工作。按照區塊分區是當我們不知道我們所要操作的集合的大小的時候，可以使用按照區塊分區，在按區塊分區中，并行循環或查詢中的每個線程或任務都使用一個區塊中一定數量的源元素，對它們進行處理，然后返回檢索其他元素。分區程序可確保分發所有元素，并且沒有重復項。區塊可為任意大小。

　　通常，只有當委托的執行時間為較短到中等程度，源具有大量的元素，并且每個分區的總工作量大致相等時，按范圍分區的速度才會較快。因此，按區塊分區的速度在大多數情況下較快。對于元素數量很少或委托執行時間較長的源，則按區塊分區和按范圍分區的性能大致相等。

　　那么我們如何實現動態分區呢？下面有一個摘自MSDN的示例。

　　每次分區對枚舉器調用 MoveNext 時，枚舉器都會提供包含一個列表元素的分區。對于 PLINQ 和 ForEach，分區是一個 Task 實例。由于請求同時在多個線程上發生，因此對當前索引的訪問是同步的。

 1 //
 2 // An orderable dynamic partitioner for lists
 3 //
 4 class OrderableListPartitioner<TSource> : OrderablePartitioner<TSource>
 5 {
 6 private readonly IList<TSource> m_input;
 7 
 8 public OrderableListPartitioner(IList<TSource> input)
 9 : base(true, false, true)
 10  {
 11 m_input = input;
 12  }
 13 
 14 // Must override to return true.
 15 public override bool SupportsDynamicPartitions
 16  {
 17 get
 18  {
 19 return true;
 20  }
 21  }
 22 
 23 public override IList<IEnumerator<KeyValuePair<long, TSource>>>
 24 GetOrderablePartitions(int partitionCount)
 25  {
 26 var dynamicPartitions = GetOrderableDynamicPartitions();
 27 var partitions =
 28 new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
 29 
 30 for (int i = 0; i < partitionCount; i++)
 31  {
 32 partitions[i] = dynamicPartitions.GetEnumerator();
 33  }
 34 return partitions;
 35  }
 36 
 37 public override IEnumerable<KeyValuePair<long, TSource>>
 38  GetOrderableDynamicPartitions()
 39  {
 40 return new ListDynamicPartitions(m_input);
 41  }
 42 
 43 private class ListDynamicPartitions
 44 : IEnumerable<KeyValuePair<long, TSource>>
 45  {
 46 private IList<TSource> m_input;
 47 private int m_pos = 0;
 48 
 49 internal ListDynamicPartitions(IList<TSource> input)
 50  {
 51 m_input = input;
 52  }
 53 
 54 public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
 55  {
 56 while (true)
 57  {
 58 // Each task gets the next item in the list. The index is 
 59 // incremented in a thread-safe manner to avoid races.
 60 int elemIndex = Interlocked.Increment(ref m_pos) - 1;
 61 
 62 if (elemIndex >= m_input.Count)
 63  {
 64 yield break;
 65  }
 66 
 67 yield return new KeyValuePair<long, TSource>(
 68  elemIndex, m_input[elemIndex]);
 69  }
 70  }
 71 
 72  IEnumerator IEnumerable.GetEnumerator()
 73  {
 74 return
 75 ((IEnumerable<KeyValuePair<long, TSource>>)this)
 76  .GetEnumerator();
 77  }
 78  }
 79 }
 80 
 81 class ConsumerClass
 82 {
 83 static void Main()
 84  {
 85 var nums = Enumerable.Range(0, 10000).ToArray();
 86 OrderableListPartitioner<int> partitioner = new OrderableListPartitioner<int>(nums);
 87 
 88 // Use with Parallel.ForEach
 89 Parallel.ForEach(partitioner, (i) => Console.WriteLine(i));
 90 
 91 
 92 // Use with PLINQ
 93 var query = from num in partitioner.AsParallel()
 94 where num % 2 == 0
 95 select num;
 96 
 97 foreach (var v in query)
 98  Console.WriteLine(v);
 99  }
100 }

　　這是按區塊分區的示例，其中每個區塊都由一個元素組成。通過一次提供多個元素，您可以減少鎖爭用，并在理論上實現更快的性能。但是，有時較大的區塊可能需要額外的負載平衡邏輯才能使所有線程在工作完成之前保持忙碌。