九、多线程之TaskAdvanced
1、Parallel常用方法
System.Threading.Task中的Parallel.For和Parallel.Foreach是真正的的多核处理器并行执行程序。
并行与并发的区别
private void ParallelKnoledgePoints()
{
{
//最简洁的将串行的代码并行化，并行线程
Parallel.Invoke(() => this.DoSomethingLong($"btnParallelClick Invoke this ThreadId = {Thread.CurrentThread.ManagedThreadId.ToString("00")}"),
() => this.DoSomethingLong($"btnParallelClick Invoke this ThreadId = {Thread.CurrentThread.ManagedThreadId.ToString("00")}"),
() => this.DoSomethingLong($"btnParallelClick Invoke this ThreadId = {Thread.CurrentThread.ManagedThreadId.ToString("00")}"),
() => this.DoSomethingLong($"btnParallelClick Invoke this ThreadId = {Thread.CurrentThread.ManagedThreadId.ToString("00")}"),
() => this.DoSomethingLong($"btnParallelClick Invoke this ThreadId = {Thread.CurrentThread.ManagedThreadId.ToString("00")}"));
}
{
//Paraller.for它会在底层根据硬件线程的运行状况来充分的使用所有的可利用的硬件线程
//注意这里的Parallel.for的步行是1
Parallel.For(0, 5, i => this.DoSomethingLong($"btnPallelClick For {i}"));
}
{
//forEach的独到之处就是可以将数据进行分区，每一个小区内实现串行计算，分区采用Partitioner.Create实现。
//Partitioner是分区器
int[] intArray = new int[] { 1, 2, 3, 4, 5 };
Parallel.ForEach(intArray, i => this.DoSomethingLong($"btnPallelClick Foreach {i}"));
}
}
2、控制线程数量
/// 
/// 
3、获取到子线程中的异常
/// 
4、取消其它线程之全局变量法
/// 
5、取消其它线程之标准做法
/// 
6、取消线程场景
/// 
7、多线程中的临时变量
/// 
8、线程安全问题
/// 为实现IProducerConsumerCollection的线程安全集合提供阻塞和限制功能
/// ConcurrentBag表示对象的的线程安全的无序集合
/// ConcurrentDictionary表示可由多个线程同时访问的键值对的线程安全集合
/// ConcurrentQueue表示线程安全的先进先出（FIFO）集合即线程安全的队列
/// ConcurrentStack表示线程安全的后进先出（LIFO）集合即线程安全的栈
/// OrderablePartitioner表示讲一个可排序数据源拆分成多个分区的特定方式
/// Partitioner提供针对数组、列表和可枚举项的常见分区策略
/// Partitioner表示将一个数据源拆分成多个分区的特定方式
///
/// 二、Lock锁，排他性，独占，反多线程的，不推荐
///
/// 三、线程安全问题一般发生在全局变量、共享变量、硬盘文件等，只要是多线程都能访问和修改的公共数据
/// 既然多线程去操作会有线程安全问题，那么就拆分数据源，然后每一个线程对标于单独的某一个数据块
/// 多线程操作完毕以后，再合并数据，爬虫实战会有应用
///
private int SyncNum = 0;
private int ASyncNum = 0;
//使用lock的话，这里一定使用静态变量，而且一定要是object对象
//因为static不会被回收，readonly只能读不能改
private static readonly object obj_Form = new object();
private void ThreadSafety()
{
for(int i = 0; i < 10000; i++)
{
this.SyncNum++;
}
List<Task> taskList = new List<Task>();
for(int i = 0; i < 10000; i++)
{
taskList.Add(Task.Run(() =>
{
this.ASyncNum++;
}));
}
Task.WaitAll(taskList.ToArray());
Console.WriteLine($"SyncNum = {this.SyncNum} ASyncNum = {this.ASyncNum}");
//执行结果：
//this.SycnNum = 10000;
//this.ASyncNum = 9988;
//而且操作多次发现this.SyncNum的值是相同的，但是this.ASyncNum的值不同，而且小于1000
//为什么？因为线程安全问题
//多个线程对同一个栈内存中的数据进行操作时，可能会把上一个线程的结果覆盖掉
List<int> list = new List<int>();
BlockingCollection<int> blockingCollection = new BlockingCollection<int>();
ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();
ConcurrentDictionary<string, int> concurrentDictionary = new ConcurrentDictionary<string, int>();
ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();
ConcurrentStack<int> concurrentStack = new ConcurrentStack<int>();
//OrderablePartitioner orderablePartitioner = new OrderablePartitioner();
for(int i = 0; i < 10000; i++)
{
int k = i;
Task.Run(() =>
{
list.Add(k);
blockingCollection.Add(k);
concurrentBag.Add(k);
concurrentDictionary.TryAdd($"concurrentDictionary_{k}", k);
concurrentQueue.Enqueue(k);
concurrentStack.Push(k);
});
}
Console.WriteLine($"listCount = {list.Count()}");
Console.WriteLine($"blockingCollectionCount = {blockingCollection.Count()} " +
$"concurrentBagCount = {concurrentBag.Count()} " +
$"concurrentDictionaryCount = {concurrentDictionary.Count()} " +
$"concurrentQueueCount = {concurrentQueue.Count()} " +
$"concurrentStackCount = {concurrentStack.Count()}");
//标准锁，锁对象，引用类型但是不要锁string，可能会冲突
//强烈建议，以后使用lock的话，按照标准格式private static readonly object obj_Form = new object();
List<int> lockList = new List<int>();
for(int i = 0; i < 10000; i++)
{
int k = i;
Task.Run(() =>
{
lock (obj_Form)//只允许一个线程从这里经过，这不就是单线程了吗？lock其实是反多线程的
{
lockList.Add(k);
}
});
}
Console.WriteLine($"lockListCount = {lockList.Count()}");
}