开发核心源码解析

Ⅰ “SpringCloud原理”Ribbon核心组件以及运行原理万字源码剖析

大家好，本文我将继续来剖析SpringCloud中负载均衡组件Ribbon的源码。本来我是打算接着OpenFeign动态代理生成文章直接讲Feign是如何整合Ribbon的，但是文章写了一半发现，如果不把Ribbon好好讲清楚，那么有些Ribbon的细节理解起来就很困难，所以我还是打算单独写一篇文章来剖析Ribbon的源码，这样在讲Feign整合Ribbon的时候，我就不再赘述这些细节了。好了，话不多说，直接进入主题。

这是个很简单的东西，就是服务实例数据的封装，里面封装了服务实例的ip和端口之类的，一个服务有很多台机器，那就有很多个Server对象。

ServerList是个接口，泛型是Server，提供了两个方法，都是获取服务实例列表的，这两个方法其实在很多实现类中实现是一样的，没什么区别。这个接口很重要，因为这个接口就是Ribbon获取服务数据的来源接口，Ribbon进行负载均衡的服务列表就是通过这个接口来的，那么可以想一想是不是只要实现这个接口就可以给Ribbon提供服务数据了？事实的确如此，在SpringCloud中，eureka、nacos等注册中心都实现了这个接口，都将注册中心的服务实例数据提供给Ribbon，供Ribbon来进行负载均衡。

通过名字也可以知道，是用来更新服务注册表的数据，他有唯一的实现，就是PollingServerListUpdater，这个类有一个核心的方法，就是start，我们来看一下start的实现。

通过这段方法我们可以看出，首先通过isActive.compareAndSet(false, true)来保证这个方法只会被调用一下，然后封装了一个Runnable，这个Runnable干了一件核心的事，就是调用传入的updateAction的doUpdate方法，然后将Runnable扔到了带定时调度功能的线程池，经过initialDelayMs（默认1s）时间后，会调用一次，之后都是每隔refreshIntervalMs（默认30s）调用一次Runnable的run方法，也就是调用updateAction的doUpdate方法。

所以这个类的核心作用就是每隔30s会调用一次传入的updateAction的doUpdate方法的实现，记住这个结论。

IRule是负责负载均衡的算法的，也就是真正实现负载均衡获取一个服务实例就是这个接口的实现。比如说实现类RandomRule，就是从一堆服务实例中随机选取一个服务实例。

就是一个配置接口，有个默认的实现DefaultClientConfigImpl，通过这个可以获取到一些配置Ribbon的一些配置。

这个接口的作用，对外主要提供了获取服务实例列表和选择服务实例的功能。虽然对外主要提供获取服务的功能，但是在实现的时候，主要是用来协调上面提到的各个核心组件的，使得他们能够协调工作，从而实现对外提供获取服务实例的功能。

这个接口的实现有好几个实现类，但是我讲两个比较重要的。

BaseLoadBalancer

核心属性

allServerList：缓存了所有的服务实例数据

upServerList：缓存了能够使用的服务实例数据。

rule：负载均衡算法组件，默认是RoundRobinRule

核心方法

setRule：这个方法是设置负载均衡算法的，并将当前这个ILoadBalancer对象设置给IRule，从这可以得出一个结论，IRule进行负载均衡的服务实例列表是通过ILoadBalancer获取的，也就是 IRule 和 ILoadBalancer相互引用。setRule(rule)一般是在构造对象的时候会调用。

chooseServer：就是选择一个服务实例，是委派给IRule的choose方法来实现服务实例的选择。

BaseLoadBalancer这个实现类总体来说，已经实现了ILoadBalancer的功能的，所以这个已经基本满足使用了。

说完BaseLoadBalancer这个实现类，接下来说一下DynamicServerListLoadBalancer实现类。DynamicServerListLoadBalancer继承自BaseLoadBalancer，DynamicServerListLoadBalancer主要是对BaseLoadBalancer功能进行扩展。

DynamicServerListLoadBalancer

成员变量

serverListImpl：上面说过，通过这个接口获取服务列表

filter:起到过滤的作用，一般不care

updateAction：是个匿名内部类，实现了doUpdate方法，会调用updateListOfServers方法

serverListUpdater：上面说到过，默认就是唯一的实现类PollingServerListUpdater，也就是每个30s就会调用传入的updateAction的doUpdate方法。

这不是巧了么，serverListUpdater的start方法需要一个updateAction，刚刚好成员变量有个updateAction的匿名内部类的实现，所以serverListUpdater的start方法传入的updateAction的实现其实就是这个匿名内部类。

那么哪里调用了serverListUpdater的start方法传入了updateAction呢？是在构造的时候调用的，具体的调用链路是调用 restOfInit -> ()，这里就不贴源码了

所以，其实DynamicServerListLoadBalancer在构造完成之后，默认每隔30s中，就会调用updateAction的匿名内部类的doUpdate方法，从而会调用updateListOfServers。所以我们来看一看 updateListOfServers 方法干了什么。

这个方法实现很简单，就是通过调用 ServerList 的getUpdatedListOfServers获取到一批服务实例数据，然后过滤一下，最后调用updateAllServerList方法，进入updateAllServerList方法。

其实很简单，就是调用每个服务实例的setAlive方法，将isAliveFlag设置成true，然后调用setServersList。setServersList这个方法的主要作用是将服务实例更新到内部的缓存中，也就是上面提到的allServerList和upServerList，这里就不贴源码了。

其实分析完updateListOfServers方法之后，再结合上面源码的分析，我们可以清楚的得出一个结论，那就是默认每隔30s都会重新通过ServerList组件获取到服务实例数据，然后更新到BaseLoadBalancer缓存中，IRule的负载均衡所需的服务实例数据，就是这个内部缓存。

从DynamicServerListLoadBalancer的命名也可以看出，他相对于父类BaseLoadBalancer而言，提供了动态更新内部服务实例列表的功能。

为了便于大家记忆，我画一张图来描述这些组件的关系以及是如何运作的。

说完一些核心的组件，以及他们跟ILoadBalancer的关系之后，接下来就来分析一下，ILoadBalancer是在ribbon中是如何使用的。

ILoadBalancer是一个可以获取到服务实例数据的组件，那么服务实例跟什么有关，那么肯定是跟请求有关，所以在Ribbon中有这么一个抽象类，，这个是用来执行请求的，我们来看一下这个类的构造。

通过上面可以看出，在构造的时候需要传入一个ILoadBalancer。

中有一个方法executeWithLoadBalancer，这个是用来执行传入的请求，以负载均衡的方式。

这个方法构建了一个LoadBalancerCommand，随后调用了submit方法，传入了一个匿名内部类，这个匿名内部类中有这么一行代码很重要。

这行代码是根据给定的一个Server重构了URI，这是什么意思呢？举个例子，在OpenFeign那一篇文章我说过，会根据服务名拼接出类似 http:// ServerA 的地址，那时是没有服务器的ip地址的，只有服务名，假设请求的地址是 http:// ServerA/api/sayHello ，那么reconstructURIWithServer干的一件事就是将ServerA服务名替换成真正的服务所在的机器的ip和端口，假设ServerA所在的一台机器（Server里面封装了某台机器的ip和端口）是192.168.1.101:8088，那么重构后的地址就变成 http:// 192.168.1.101:8088/api/ sayHello ，这样就能发送http请求到ServerA服务所对应的一台服务器了。

之后根据新的地址，调用这个类中的execute方法来执行请求，execute方法是个抽象方法，也就是交给子类实现，子类就可以通过实现这个方法，来发送http请求，实现rpc调用。

那么这台Server是从获取的呢？其实猜猜也知道，肯定是通过ILoadBalancer获取的，因为submit方法比较长，这里我直接贴出submit方法中核心的一部分代码

就是通过selectServer来选择一个Server的，selectServer我就不翻源码了，其实最终还是调用ILoadBalancer的方法chooseServer方法来获取一个服务，之后就会调用上面的说的匿名内部类的方法，重构URI，然后再交由子类的execut方法来实现发送http请求。

所以，通过对的executeWithLoadBalancer方法，我们可以知道，这个抽象类的主要作用就是通过负载均衡算法，找到一个合适的Server，然后将你传入的请求路径 http:// ServerA/api/sayHello 重新构建成类似 http:// 192.168.1.101:8088/api/ sayHello 这样，之后调用子类实现的execut方法，来发送http请求，就是这么简单。

到这里其实Ribbon核心组件和执行原理我就已经说的差不多了，再来画一张图总结一下

说完了Ribbon的一些核心组件和执行原理之后，我们再来看一下在SpringCloud环境下，这些组件到底是用的哪些实现，毕竟有写时接口，有的是抽象类。

Ribbon的自动装配类：RibbonAutoConfiguration，我拎出了核心的源码

RibbonAutoConfiguration配置类上有个@RibbonClients注解，接下来讲解一下这个注解的作用

SpringClientFactory是不是感觉跟OpenFeign中的FeignContext很像，其实两个的作用是一样的，SpringClientFactory也继承了NamedContextFactory，实现了配置隔离，同时也在构造方法中传入了每个容器默认的配置类RibbonClientConfiguration。至于什么是配置隔离，我在OpenFeign那篇文章说过，不清楚的小伙伴可以后台回复feign01即可获得文章链接。

配置优先级问题

优先级最低的就是FeignContext和SpringClientFactory构造时传入的配置类

至于优先级怎么来的，其实是在NamedContextFactory中createContext方法中构建时按照配置的优先级一个一个传进去的。

RibbonClientConfiguration提供的默认的bean

接下来我们看一下RibbonClientConfiguration都提供了哪些默认的bean

配置类对应的bean，这里设置了ConnectTimeout和ReadTimeout都是1s中。

IRule，默认是ZoneAvoidanceRule，这个Rule带有过滤的功能，过滤哪些不可用的分区的服务（这个过滤可以不用care），过滤成功之后，继续采用线性轮询的方式从过滤结果中选择一个出来。至于这个propertiesFactory，可以不用管，这个是默认读配置文件的中的配置，一般不设置，后面看到都不用care。

至于为什么容器选择NacosServerList而不是ConfigurationBasedServerList，主要是因为这个配置类是通过@RibbonClients导入的，也就是比SpringClientFactory导入的RibbonClientConfiguration配置类优先级高。

ServerListUpdater，就是我们剖析的PollingServerListUpdater，默认30s更新一次BaseLoadBalancer内部服务的缓存。

那么在springcloud中，上图就可以加上注册中心。

三、总结

本文剖析了Ribbon这个负载均衡组件中的一些核心组件的源码，并且将这些组件之间的关系一一描述清楚，同时也剖析了在发送请求的时候是如何通过ILoadBalancer获取到一个服务实例，重构URI的过程。希望本篇文章能够让你知道Ribbon是如何工作的。

Ⅱ 如何开发自己的httpserver-nanohttpd源码解读

现在作为一个开发人员，http server相关的内容已经是无论如何都要了解的知识了。用curl发一个请求，配置一下apache，部署一个web server对我们来说都不是很难，但要想搞清楚这些背后都发生了什么技术细节还真不是很简单的。所以新的系列将是分享我学习Http Server的过程。

NanoHttpd是Github上的一个开源项目，号称只用一个java文件就能创建一个http server，我将通过分析NanoHttpd的源码解析如何开发自己的HttpServer。Github 地址：https://github.com/NanoHttpd/nanohttpd

在开始前首先简单说明HttpServer的基本要素：
1.能接受HttpRequest并返回HttpResponse
2.满足一个Server的基本特征，能够长时间运行

关于Http协议一般HttpServer都会声明支持Http协议的哪些特性，nanohttpd作为一个轻量级的httpserver只实现了最简单、最常用的功能，不过我们依然可以从中学习很多。

首先看下NanoHttpd类的start函数

[java] view plain
public void start() throws IOException {
myServerSocket = new ServerSocket();
myServerSocket.bind((hostname != null) ? new InetSocketAddress(hostname, myPort) : new InetSocketAddress(myPort));

myThread = new Thread(new Runnable() {
@Override
public void run() {
do {
try {
final Socket finalAccept = myServerSocket.accept();
registerConnection(finalAccept);
finalAccept.setSoTimeout(SOCKET_READ_TIMEOUT);
final InputStream inputStream = finalAccept.getInputStream();
asyncRunner.exec(new Runnable() {
@Override
public void run() {
OutputStream outputStream = null;
try {
outputStream = finalAccept.getOutputStream();
TempFileManager tempFileManager = tempFileManagerFactory.create();
HTTPSession session = new HTTPSession(tempFileManager, inputStream, outputStream, finalAccept.getInetAddress());
while (!finalAccept.isClosed()) {
session.execute();
}
} catch (Exception e) {
// When the socket is closed by the client, we throw our own SocketException
// to break the "keep alive" loop above.
if (!(e instanceof SocketException && "NanoHttpd Shutdown".equals(e.getMessage()))) {
e.printStackTrace();
}
} finally {
safeClose(outputStream);
safeClose(inputStream);
safeClose(finalAccept);
unRegisterConnection(finalAccept);
}
}
});
} catch (IOException e) {
}
} while (!myServerSocket.isClosed());
}
});
myThread.setDaemon(true);
myThread.setName("NanoHttpd Main Listener");
myThread.start();
}
1.创建ServerSocket，bind制定端口

2.创建主线程，主线程负责和client建立连接
3.建立连接后会生成一个runnable对象放入asyncRunner中，asyncRunner.exec会创建一个线程来处理新生成的连接。
4.新线程首先创建了一个HttpSession，然后while(true)的执行httpSession.exec。
这里介绍下HttpSession的概念，HttpSession是java里Session概念的实现，简单来说一个Session就是一次httpClient->httpServer的连接，当连接close后session就结束了，如果没结束则session会一直存在。这点从这里的代码也能看到：如果socket不close或者exec没有抛出异常（异常有可能是client段断开连接）session会一直执行exec方法。
一个HttpSession中存储了一次网络连接中server应该保存的信息，比如：URI，METHOD，PARAMS，HEADERS，COOKIES等。
5.这里accept一个client的socket就创建一个独立线程的server模型是ThreadServer模型，特点是一个connection就会创建一个thread，是比较简单、常见的socket server实现。缺点是在同时处理大量连接时线程切换需要消耗大量的资源，如果有兴趣可以了解更加高效的NIO实现方式。

当获得client的socket后自然要开始处理client发送的httprequest。

Http Request Header的parse：

[plain] view plain
// Read the first 8192 bytes.
// The full header should fit in here.
// Apache's default header limit is 8KB.
// Do NOT assume that a single read will get the entire header at once!
byte[] buf = new byte[BUFSIZE];
splitbyte = 0;
rlen = 0;
{
int read = -1;
try {
read = inputStream.read(buf, 0, BUFSIZE);
} catch (Exception e) {
safeClose(inputStream);
safeClose(outputStream);
throw new SocketException("NanoHttpd Shutdown");
}
if (read == -1) {
// socket was been closed
safeClose(inputStream);
safeClose(outputStream);
throw new SocketException("NanoHttpd Shutdown");
}
while (read > 0) {
rlen += read;
splitbyte = findHeaderEnd(buf, rlen);
if (splitbyte > 0)
break;
read = inputStream.read(buf, rlen, BUFSIZE - rlen);
}
}
1.读取socket数据流的前8192个字节，因为http协议中头部最长为8192

2.通过findHeaderEnd函数找到header数据的截止位置，并把位置保存到splitbyte内。

[java] view plain
if (splitbyte < rlen) {
inputStream.unread(buf, splitbyte, rlen - splitbyte);
}

parms = new HashMap<String, String>();
if(null == headers) {
headers = new HashMap<String, String>();

}
1.http协议规定header和body之间使用两个回车换行分割

1.Http协议第一行是Method URI HTTP_VERSION

2.后面每行都是KEY:VALUE格式的header
3.uri需要经过URIDecode处理后才能使用
4.uri中如果包含？则表示有param，httprequest的param一般表现为:/index.jsp?username=xiaoming&id=2

下面是处理cookie，不过这里cookie的实现较为简单，所以跳过。之后是serve方法，serve方法提供了用户自己实现httpserver具体逻辑的很好接口。在NanoHttpd中的serve方法实现了一个默认的简单处理功能。

[java] view plain

发送response的步骤如下：

1.设置mimeType和Time等内容。
2.创建一个PrintWriter，按照HTTP协议依次开始写入内容
3.第一行是HTTP的返回码
4.然后是content-Type
5.然后是Date时间
6.之后是其他的HTTP Header
7.设置Keep-Alive的Header，Keep-Alive是Http1.1的新特性，作用是让客户端和服务器端之间保持一个长链接。
8.如果客户端指定了ChunkedEncoding则分块发送response，Chunked Encoding是Http1.1的又一新特性。一般在response的body比较大的时候使用，server端会首先发送response的HEADER，然后分块发送response的body，每个分块都由chunk length\r\n和chunk data\r\n组成，最后由一个0\r\n结束。

9.如果没指定ChunkedEncoding则需要指定Content-Length来让客户端指定response的body的size，然后再一直写body直到写完为止。

Ⅲ 面试中的网红Vue源码解析之虚拟DOM，你知多少呢深入解读diff算法

众所周知，在前端的面试中，面试官非常爱考dom和diff算法。比如，可能会出现在以下场景

滴滴滴，面试官发来一个面试邀请。接受邀请📞

我们都知道， key 的作用在前端的面试是一道很普遍的题目，但是呢，很多时候我们都只浮于知识的表面，而没有去深挖其原理所在，这个时候我们的竞争力就在这被拉下了。所以呢，深入学习原理对于提升自身的核心竞争力是一个必不可少的过程。

在接下来的这篇文章中，我们将讲解面试中很爱考的虚拟DOM以及其背后的diff算法。 请认真阅读本文～文末有学习资源免费共享！！！

虚拟DOM是用JavaScript对象描述DOM的层次结构。DOM中的一切属性都在虚拟DOM中有对应的属性。本质上是JS 和 DOM 之间的一个映射缓存。

要点：虚拟 DOM 是 JS 对象；虚拟 DOM 是对真实 DOM 的描述。

diff发生在虚拟DOM上。diff算法是在新虚拟DOM和老虚拟DOM进行diff（精细化比对），实现最小量更新，最后反映到真正的DOM上。

我们前面知道diff算法发生在虚拟DOM上，而虚拟DOM是如何实现的呢？实际上虚拟DOM是有一个个虚拟节点组成。

h函数用来产生虚拟节点（vnode）。虚拟节点有如下的属性：
1）sel： 标签类型，例如 p、div；
2）data： 标签上的数据，例如 style、class、data-*；
3）children ：子节点；
4） text： 文本内容；
5）elm：虚拟节点绑定的真实 DOM 节点；

通过h函数的嵌套，从而得到虚拟DOM树。

我们编写了一个低配版的h函数，必须传入3个参数，重载较弱。

形态1：h('div', {}, '文字')
形态2：h('div', {}, [])
形态3：h('div', {}, h())

首先定义vnode节点，实际上就是把传入的参数合成对象返回。

[图片上传失败...(image-7a9966-1624019394657)]
然后编写h函数，根据第三个参数的不同进行不同的响应。

当我们进行比较的过程中，我们采用的4种命中查找策略：
1）新前与旧前：命中则指针同时往后移动。
2）新后与旧后：命中则指针同时往前移动。
3）新后与旧前：命中则涉及节点移动，那么新后指向的节点，移到 旧后之后 。
4）新前与旧后：命中则涉及节点移动，那么新前指向的节点，移到 旧前之前 。

命中上述4种一种就不在命中判断了，如果没有命中，就需要循环来寻找，移动到旧前之前。直到while(新前<=新后&&旧前<=就后)不成立则完成。

如果是新节点先循环完毕，如果老节点中还有剩余节点(旧前和旧后指针中间的节点)，说明他们是要被删除的节点。

如果是旧节点先循环完毕，说明新节点中有要插入的节点。

1.什么是Virtual DOM 和Snabbdom
2.手写底层源码h函数
3.感受Vue核心算法之diff算法
4.snabbdom之核心h函数的工作原理

1、零基础入门或者有一定基础的同学、大中院校学生
2、在职从事相关工作1-2年以及打算转行前端的朋友
3、对前端开发有兴趣人群

Ⅳ 40K稳了！掌握Android-Framework源码真是YYDS！

前两天看到字节一个老哥写的帖子，提到高阶开发者必须掌握的技能，其中他明确提出了“精通Framework”。

为啥Framework对Android开发人员如此重要？

我在面试的时候也经常看到一些程序员写“精通Framework”，但 大多数人对精通存在一定误区 。

Framework始终穿插在 App 整个研发生命周期中，不管是从 0 到 1 的建立阶段，还是从 1 到 N 打磨阶段，都离不开Framework 。所以与它相关的知识都尤为重要，面试官会通过连环炮来试探你相关技能的边际所在。

对于大部分程序员来说，Framework用了很久，但依然会出现面对棘手问题束手无策的状况，大多是因为 对源码和底层原理模糊不清 。

为了帮助大家深刻理解Framework源码，并将它应用到工作中，前段时间 整理收集的关于Android Framework的知识脑图总结和源码学习手册文档！ 既能够 夯实底层原理、源码解析等核心技术点，又能够掌握普通开发者，难以触及的复杂系统问题设计方案 。那你在工作中、团队里、面试时，也就拥有了同行难以复制的核心竞争力。如果你正在进阶这一块，可以来参考Github上的这个 《Android Framework源码解析手册》

内容展示

作为过来人，发现很多学习者和实践者都在 Android Framework上面临着很多的困扰，比如：

总之，一旦遇到问题，很少人能够由点及面逆向分析 ，最终找到瓶颈点和最优解决方案， 而Framework是Android开发的深水区，也是衡量一个Android程序员能力高低的标准。

Ⅳ 《深入理解SPARK核心思想与源码分析》epub下载在线阅读，求百度网盘云资源

《深入理解SPARK》（耿嘉安）电子书网盘下载免费在线阅读

资源链接：

链接：

书名：深入理解SPARK

作者：耿嘉安

豆瓣评分：7.2

出版社：机械工业出版社

出版年份：2016-1-1

页数：469

内容简介：

《深入理解SPARK：核心思想与源码分析》结合大量图和示例，对Spark的架构、部署模式和工作模块的设计理念、实现源码与使用技巧进行了深入的剖析与解读。

《深入理解SPARK：核心思想与源码分析》一书对Spark1.2.0版本的源代码进行了全面而深入的分析，旨在为Spark的优化、定制和扩展提供原理性的指导。阿里巴巴集团专家鼎力推荐、阿里巴巴资深Java开发和大数据专家撰写。

本书分为三篇：

准备篇（第1～2章），介绍了Spark的环境搭建、设计理念与基本架构，帮助读者了解一些背景知识。

核心设计篇（第3～7章），着重讲解SparkContext的初始化、存储体系、任务提交与执行、计算引擎及部署模式的原理和源码分析。通过这部分的内容，读者可以通过源码剖析更加深入理解Spark的核心设计与实现，以便在实际使用中能够快速解决线上问题并对性能进行调优。

扩展篇（第8～11章），主要讲解基于Spark核心的各种扩展及应用，包括SQL处理引擎、Hive处理、流式计算框架Spark Streaming、图计算框架GraphX、机器学习库MLlib等内容。通过阅读这部分内容，读者可以扩展实际项目中对Spark的应用场景，让Spark焕发活力。

作者简介：

耿嘉安，10年IT行业相关经验。就职于阿里巴巴商家业务事业部，任资深Java工程师，专注于开源和大数据领域，目前与小伙伴们基于ODPS构建阿里的大数据商业解决方案——御膳房。在大量的工作实践中，对J2EE、JVM、Tomcat、Spring、Hadoop、Spark、MySQL、Redis都有深入研究，尤其喜欢剖析开源项目的源码实现。早期从事J2EE企业级应用开发，对Java相关技术有独到见解。业余时间喜欢研究中国古代历史，古诗词，旅游，足球等。

Ⅵ futex内核实现源码分析（3）

futex同步机制包括用户态的原子操作和内核态的futex系统调用两部分组成，其调用原型如下：

在futex系统调用内部是通过do_futex()完成具体操作

futex系统调用的参数很多，而do_futex的参数比futex还要多出一个来。这是由于同一个futex调用要根据不同的操作类型来完成不同的操作，而具体的操作所需的参数因目的不同而有所差异，每种具体的操作类型所需的参数数目以及具体参数的含义由其参数op决定。具体op操作类型的定义具体如下：

具体的futex系统调用如下，在futex(……)中根据操作类型op对参数进行调整，然后调用do_futex(……)。主要有以下几种情况：

在do_futex(……)中，主要根据op代表的具体操作类型进行不同分支的操作。例如FUTEX_WAIT执行futex_wait(uaddr, flags, val, timeout, val3)，FUTEX_WAKE则执行futex_wake(uaddr, flags, val, val3)，这是最基本futex阻塞唤醒操作。可以看到FUTEX_WAIT_BITSET和FUTEX_WAKE_BITSET最终调用的具体操作函数也是futex_wait(uaddr, flags, val, timeout, val3)和futex_wake(uaddr, flags, val, val3)，只不过FUTEX_WAIT和FUTEX_WAKE在执行具体操作之前将bitset参数val3设置为全匹配。另外操作函数中flag参数指明该futex变量时进程间共享的还进程私有的，该参数具体值根据op的值设定。

后面会主要对futex_wait(……)和futex_wake(……)进行详细分析。

参考：
http://www.tuicool.com/articles/feUR73
http://blog.csdn.net/jianchaolv/article/details/7544316

Ⅶ futex内核实现源码分析（2）

由上一章节可知，futex变量创建于用户空间，在进程或线程间共享，当进程或线程想要进入临界区时，通常会判断futex变量是否满足条件，若满足则成功进入临界区，否则则阻塞在该futex变量上；当进程或线程将要离开临界区时，则会唤醒阻塞在futex变量上的其他进程或线程。在内核中通过struct futex_q结构将一个futex变量与一个挂起的进程（线程）关联起来。

struct futex_q：

union futex_key：futex变量地址标识

在内核中通过一个哈希表来维护所有挂起阻塞在futex变量上的进程（线程），不同的futex变量会根据其地址标识计算出一个hash key定位到一个哈希桶链上，因此挂起阻塞在同一个futex变量的所有进程（线程）会定位到同一个哈希桶链上。

struct futex_hash_bucket ：

futex哈希表：

同一进程下不同线程阻塞在futex变量模型：

内核fuetx初始化，初始化futex哈希表的每一个哈希桶链的头。

Ⅷ 深入理解spark核心思想与源码分析 怎么样

SparkSQL主要的推动者是Databricks。提到SparkSQL不得不提的就是Shark。Shark可以理解为Spark社区这边搞的一个”HiveonSpark”，把Hive的物理执行计划使用Spark计算引擎去执行。这里面会有一些问题，Hive社区那边没有把物理执行计划到执行引擎这个步骤抽象出公共API，所以Spark社区这边要自己维护一个Hive的分支，而且Hive的设计和发展不太会考虑到如何优化Spark的Job。但是前面提到的HiveonSpark却是和Hive一起发布的，是由Hive社区控制的。所以后来Spark社区就停止了Shark的开发转向SparkSQL（“坑了”一部分当时信任Shark的人）。SparkSQL是把SQL解析成RDD的transformation和action，而且通过catalyst可以自由、灵活的选择最优执行方案。对数据库有深入研究的人就会知道，SQL执行计划的优化是一个非常重要的环节，SparkSQL在这方面的优势非常明显，提供了一个非常灵活、可扩展的架构。但是SparkSQL是基于内存的，元数据放在内存里面，不适合作为数据仓库的一部分来使用。所以有了SparkSQL的HiveContext，就是兼容Hive的SparkSQL。它支持HiveQL,HiveMetastore,HiveSerDesandHiveUDFs以及JDBCdriver。这样看起来很完美，但是实际上也有一些缺点：SparkSQL依赖于Hive的一个snapshot，所以它总是比Hive的发布晚一个版本，很多Hive新的feature和bugfix它就无法包括。而且目前看Spark社区在Spark的thriftserver方面的投入不是很大，所以感觉它不是特别想朝着这个方向发展。还有一个重要的缺点就是SparkSQL目前还不能通过分析SQL来预测这个查询需要多少资源从而申请对应的资源，所以在共享集群上无法高效地分配资源和调度任务。

Ⅸ 直播源码都有哪些核心功能开发

所谓直播系统源码，直播间功能当然是必须存在的，并且随着直播行业的发展，直播间的种类也在不断增加，计时收费直播间、密码直播间等变种不断出现，比如：
计时收费直播间：粉丝按照直播时长支付一定费用，该直播间能够有效提升主播收入，并且一些忠实用户会很喜欢。
密码直播间：主播会在开播之前设定直播间的密码，粉丝只有输入正确的密码才可以进入直播间观看直播，这种房间可以被用于开办小型粉丝见面会。
一对一直播间：主播在一定时间内只能与一名用户进行连麦，这对一些忠实粉丝和土豪粉丝非常友善。付费直播间：主播在开播时设定好直播间的收费标准，粉丝需要支付一定的费用才可以进入直播间。直播列表：关注、热门、最新、新人、分类列表等主播直播列表是以多种算法进行区分的，比如热门是根据主播收到礼物的多少进行曝光排序，新人列表可能是以主播的入驻时间进行排序，关注列表则是以用户是否关注了该主播为决定性因素，这些直播列表也是从不同维度提升主播的曝光量。礼物功能：前端的普通礼物、豪华礼物、红包、商城等功能，后台的支付宝、微信、第三方接口等功能都是，礼物功能是主播和平台的收入来源之一，该功能必不可少。

Ⅹ Netty核心技术及源码剖析-Netty入站与出站机制

1、Netty的组件设计: Netty的主要组件有Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe等。
2、ChannelHandler充当了处理入站和出站数据的应用程序逻辑的容器。例如,实现ChannelInboundHandler接口(或ChannelInboundHandlerAdapter),你就可以接收入站事件和数据,这些数据会被业务逻辑处理。当要给客户端发送响应时,也可以从ChannelInboundHandler冲刷数据。业务逻辑通常写在一个或者多个ChannelInboundHandler中。ChannelOutboundHandler原理一样,只不过它是用来处理出站数据的。
3、ChannelPipeline提供了ChannelHandler链的容器。以客户端应用程序为例,如果事件的运动方向是从客户端到服务端的,那么我们称这些事件为出站的,即客户端发送给服务器端的数据会通过pipeline中的一些列ChannelOutboundHandler,并被这些Handler处理,反之则称为入站的。

1、当Netty发送或者接受一个消息的时候,就将会发生一次数据转换。入站消息会被解码:从字节转换为另一种格式(比如Java对象);如果是出站消息,它会被编码成字节。
2、Netty提供一些列实用的编解码器,他们都实现了ChannelInboundHandler或者ChannelOutboundHandler接口。在这些类中,channelRead方法已经被重写了。以入站为例,对于每个从入站Channel读取的消息,这个方法会被调用。随后,它将调用由解码器所提供的decode()方法进行解码,并将已经解码的字节转发给ChannelPipeline中的下一个ChannelInboundHandler。

1、关系继承图

2、由于不可能知道远程节点是否会一次性发送一个完整的信息,tcp有可能出现粘包拆包的问题,这个类会对入站数据进行缓冲,知道它准备好被处理。
3、一个关于ByteToMessageDecoder实例分析