并发编程的几种形式

并发编程的几种形式

在并发编程中咱们常常听到如下一些概念，今天我将尝试进行阐述。

1、并发

同时干多件事情，这就是并发的做用。

web服务器能够利用并发同时处理大量用户的请求。

只要咱们须要程序同时干多件事情，咱们就须要并发。

2、多线程

并发编程的一种形式，其采用多个线程执行程序。

线程是一个独立的运行单元,每一个进程内部有多个线程,每一个线程能够各自同时执行指令。

每一个线程有本身独立的栈,可是与进程内的其余线程共享内存。

线程池是线程更普遍的一种应用形式，其维护着必定数量的工做线程,这些线程等待着执行分配下来的任务。线程池能够随时监测线程的数量

线程池催生了另一种重要的并发形式：并行处理。

多线程并非并发编程的惟一形式，虽然.NET和Java等语言框架都对底层线程类型提供了支持，可是对开发人员并不友好，最新的.NET和Java

都提供了更高级别的抽象，让咱们开发并发程序更加方便高效。

3、并行处理

将大块的任务分割成相互独立的小块，并分配给多个同时运行的线程处理。

并行处理采用多线程，提升了处理器的利用效率。

并行编程一般不适合服务器系统，服务器自己都具备并发处理能力。

数据并行能够处理大量的彼此独立的数据，好比Hadoop等大数据处理框架。

任务并行能够将彼此独立的拆分任务同时执行。

下边看下.NET中提供的并行编程

使用Parallel.ForEach进行数据并行

void RotateMatrices(IEnumerable<Matrix> matrices, float degrees)
{
    Parallel.ForEach(matrices, matrix => matrix.Rotate(degrees));
}

 

使用Parallel.ForEach进行数据并行

IEnumerable<bool> PrimalityTest(IEnumerable<int> values)
{
    return values.AsParallel().Select(val => IsPrime(val));
}

 

数据的独立性是并行性最大化的前提，否为了确保安全性就须要引入同步，从而影响程序的并行程度。

只能最大程度的并行，可是老是消灭不了同步，数据并行的结果老是须要进行聚合，Parallel实现了响应的重载及map/reduce函数。

Parallel类的Invoke方式能够实现任务并行

void ProcessArray(double[] array)
{
    Parallel.Invoke(
        () => ProcessPartialArray(array, 0, array.Length / 2),
        () => ProcessPartialArray(array, array.Length / 2, array.Length)
    );
}
void ProcessPartialArray(double[] array, int begin, int end)
{
    // CPU 密集型的操做......
}        

 

任务并行也依赖任务的独立性，同时要注意闭包对变量的引用，即便是值类型也是引用。

任务不要特别短,也不要特别长。若是任务过短,把数据分割进任务和在线程池中调度任务的开销会很大。若是任务太长,线程池就不能进行

有效的动态调整以达到工做量的平衡。

4、异步编程

并发编程的一种形式，它采用future模式或者回调(callback)机制，以免产生没必要要的线程。

回调和事件做为老式的异步编程，在服务器端和GUI中都有普遍的应用。

一个future或者promise表明一些即将完成的操做，在.NET中的TPL中有Task和Task<TResult>，在Java中有FutureTask，在JS中有fetch(新版Firefox

和Chorm支持)。

异步编程能够在启动一个操做以后，能够继续执行而不会被阻塞，待操做执行完以后，通知future或者执行回调函数，以便告知操做结束。

异步编程是一种功能强大的并发形式，但传统的异步编程特别复杂并且不易于代码维护。.NET和Node.JS支持的async和await，让异步编程变得

跟串行编程同样简单。

下面看下.NET 的两个关键字: async 和 await 。 async 关键字加在方法声明上,它的主要目的是使方法内的 await 关键字生效。若是 async 方法有

返回值,应返回 Task<T> ;若是没有返回值,应返回 Task 。这些task 类型至关于 future,用来在异步方法结束时通知主程序。下边的例子同时请求两

个服务地址，只要有一个返回结果便可完成。

// 返回第一个响应的 URL 的数据长度。
private static async Task<int> FirstRespondingUrlAsync(string urlA, string urlB)
{
    var httpClient = new HttpClient();
    // 并发地开始两个下载任务。
    Task<byte[]> downloadTaskA = httpClient.GetByteArrayAsync(urlA);
    Task<byte[]> downloadTaskB = httpClient.GetByteArrayAsync(urlB);
    // 等待任意一个任务完成。
    Task<byte[]> completedTask =
    await Task.WhenAny(downloadTaskA, downloadTaskB);
    // 返回从 URL 获得的数据的长度。
    byte[] data = await completedTask;
    return data.Length;
}

 

5、响应式编程

一种声明式的编程模式，程序在该模式中对事件进行响应。

程序针对不一样的事件进行响应并更新本身的状态。

异步编程针对启动的操做，响应编程针对能够任何事件重复发生的异步事件。

响应式编程基于“可观察的流”(observable stream)。一旦申请了可观察流,就能够收到任意数量的数据项( OnNext ),而且流在结束时会发出一个错误(

OnError )或一个结束的通知( OnCompleted )。实际的接口以下

interface IObserver<in T>
{
    void OnNext(T item);
    void OnCompleted();
    void OnError(Exception error);
}

interface IObservable<out T>
{
    IDisposable Subscribe(IObserver<T> observer);
}

 

微软的 Reactive Extensions(Rx)库已经实现了全部接口。下面的代码中,前面是咱们不熟悉的操做符( Interval 和 Timestamp ),最后是一个 Subscribe ,

可是中间部分是咱们在 LINQ 中熟悉的操做符: Where 和 Select 。LINQ 具备的特性,Rx也都有。Rx 在此基础上增长了不少它本身的操做符,特别

是与时间有关的操做符:

Observable.Interval(TimeSpan.FromSeconds(1))
.Timestamp()
.Where(x => x.Value % 2 == 0)
.Select(x => x.Timestamp)
.Subscribe(x => Trace.WriteLine(x));

 

上面的代码中,首先是一个延时一段时间的计数器( Interval ),随后、后为每一个事件加了一个时间戳( Timestamp )。接着对事件进行过滤,只包含偶数

值( Where ),选择了时间戳的值( Timestamp ),而后当每一个时间戳值到达时,把它输入调试器( Subscribe )。可观察流的定义和其订阅是互相独立的。

上面最后一个例子与下面的代码等效:

IObservable<DateTimeOffset> timestamps =
Observable.Interval(TimeSpan.FromSeconds(1))
.Timestamp()
.Where(x => x.Value % 2 == 0)
.Select(x => x.Timestamp);
timestamps.Subscribe(x => Trace.WriteLine(x));

 

一种常规的作法是把可观察流定义为一种类型,而后将其做为 IObservable<T> 资源使用。其余类型能够订阅这些流,或者把这些流与其余操做符

组合,建立另外一个可观察流Rx 的订阅也是一个资源。 Subscribe 操做符返回一个 IDisposable ,即表示订阅完成。当你响应了那个可观察流,就得处

理这个订阅。对于hot observable(热可观察流)和 cold observable(冷可观察流)这两种对象,订阅的作法各有不一样。一个 hot observable 对象是指一直

在发生的事件流,若是在事件到达时没有订阅者,事件就丢失了。例如,鼠标的移动就是一个 hot observable 对象。cold observable 对象是始终没有

输入事件(不会主动产生事件)的观察流,它只会经过启动一个事件队列来响应订阅。例如,HTTP 下载是一个 cold observable 对象,只有在订阅后

才会发出 HTTP 请求。

6、并发集合和不可变集合

大多数并发集合经过快照，既能够确保一个线程修改数据，同时也能够容许多个线程同时枚举数据。

不可变集合的没法修改性确保了全部操做的简洁性,特别适合在并发编程中使用。

7、并发编程与函数编程

大多数并发编程技术本质上都是函数式(functional) 的。

函数式编程理念简化并发编程的设计。每个并行的片断都有输入和输出。他们不依赖于全局(或共享)变量,也不会修改全局(或共享)数据结构。

函数式编程的数据不变性在确保并发安全性的前提下，同时也防止了并发的活跃性问题。