精华内容
下载资源
问答
  • 多进程架构

    2019-06-25 07:00:00
    CPU的亲和性, 就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器,亲和性是从affinity翻译过来的,应该有点不准确,给人的感觉是亲和性就是有倾向...
        

    640?wx_fmt=png


    CPU的亲和性, 就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器,亲和性是从affinity翻译过来的,应该有点不准确,给人的感觉是亲和性就是有倾向的意思,而实际上是倒向的意思,称为CPU关联性更好,程序员的土话就是绑定CPU,绑核。


    在多核运行的机器上,每个CPU本身自己会有缓存,缓存着进程使用的信息,而进程可能会被OS调度到其他CPU上,如此,CPU cache命中率就低了,当绑定CPU后,程序就会一直在指定的cpu跑,不会由操作系统调度到其他CPU上,性能有一定的提高。


    另外一种使用绑核考虑就是将重要的业务进程隔离开,对于部分实时进程调度优先级高,可以将其绑定到一个指定核上,既可以保证实时进程的调度,也可以避免其他CPU上进程被该实时进程干扰。


    复制进程

    面对单进程单线程对多核使用不足的问题,前人的经验是启动多进程即可。理想状态下每个进程各自利用一个 CPU,以此实现多核CPU的利用。


    Node 提供了 child_process 模块,并且也提供了 child_process.fork() 函数供我们实现进程的复制。


    我们再一次将经典的示例代码存为 worker.js 文件,如下所示:


    const http = require('http')	
    	
    const server = http.createServer(	
      (req, res) => {	
        res.writeHead(200, {	
          'Content-Type': 'text/plain',	
        })	
        res.end('hello world')	
      }	
    )	
    	
    const port = Math.round((1 + Math.random()) * 1000)	
    server.listen(port, () => {	
      console.log(`port in ${port}`)	
    })


    通过 node worker.js 启动它,将会侦听1000到2000之间的一个随机端口。


    将以下代码存为 master.js,并通过 node master.js 启动它:


    const fork = require('child_process').fork	
    const cpus = require('os').cpus()	
    	
    for (let i = 0; i < cpus.length; i++) {	
      fork('./worker.js');	
    }


    这段代码将会根据当前机器上的 CPU 数量复制出对应Node进程数。在控制台会输出对应的端口


    640?wx_fmt=png

    主从模式

    著名的 Master-Worker 模式,又称主从模式。图中的进程分为两种:主进程和工作进程。这是典型的分布式架构中用于并行处理业务的模式,具备较好的可伸缩性和稳定性。主进程不负责具体的业务处理,而是负责调度或管理工作进程,它是趋向于稳定的。工作进程负责具体的业务处理,因为业务的多种多样,甚至一项业务由多人开发完成,所以工作进程的稳定性值得开发者关注。


    640?wx_fmt=png



    通过 fork() 复制的进程都是一个独立的进程,这个进程中有着独立而全新的 V8 实例。它需要至少30毫秒的启动时间和至少10 MB的内存。尽管 Node 提供了 fork() 供我们复制进程使每个CPU内核都使用上,但是依然要切记 fork() 进程是昂贵的。好在 Node 通过事件驱动的方式在单线程上解决了大并发的问题,这里启动多个进程只是为了充分将 CPU 资源利用起来,而不是为了解决并发问题。


    640?wx_fmt=png
    展开全文
  • 嵌入式平台下,应用多线程架构和多进程架构如何选择? 问题分析 该问题只有限定在嵌入式平台才有可问性,在PC平台,除非特殊限制或者系统原因,大部分复杂程序都是采用的多进程架构,因为需要充分利用资源。 该...

    说明

    • 嵌入式平台下,应用层多线程架构和多进程架构如何选择?
    • 这是一个常见的面试问题,也是程序架构的一个基础问题。

    问题分析

    • 该问题只有限定在嵌入式平台才有意义,在PC平台,除非功能较简单或者特殊限制(系统原因),大部分复杂程序都是采用的多进程架构,因为可以充分利用系统资源。
    • 该问题虽然是问选择多线程还是选择多进程,但实际应用中都是“进程+线程”的结合方式,并不是非此即彼,选择了多进程在进程中就不能创建多线程了,选择多线程就不能创建多进程了,问题的重点在于是否将功能放在多个进程中。
    • 在工作中,我既见过选择单进程多线程架构,也见过选择多进程多线程架构,两个选择并没有哪个更好,需要根据实际情况进行选择。
    • 因此该问题可以分为两个问题:
    1. 嵌入式平台下,是否必要将应用层划分为多个进程。
    2. 功能在线程和进程之间如何划分,即哪些功能适合存在于多个进程,哪些功能适合存在于单进程中多个线程。

    进程与线程对比

    • 选择之前,需要弄明白嵌入式平台下,进程和线程的区别以及各自的优缺点。

    性能

    • 在linux下,线程是轻量级进程,这句话充分体现了进程和线程在性能方面的差别。
    1. 内存,CPU等资源占用
    • 进程占用内存多,切换复杂,CPU利用率低;线程占用内存少,切换简单,CPU利用率高。
    1. 数据共享、同步
    • 进程数据共享复杂,需要用IPC;数据是分开的,同步简单;线程因为共享进程数据,数据共享简单,但也是因为这个原因导致同步复杂。
    1. 创建销毁、切换
    • 进程创建销毁、切换复杂、速度慢;线程创建销毁、切换简单,速度很快。

    资源分配

    • 多进程比单进程拥有更大的内存访问范围。
    • 有些操作系统的进程调度,线程和进程是平等的,但是有些系统,进程能够或得更多的CPU时间片。
    • 以上是在资源充足的情况下,例如:PC端,但是在嵌入式平台,资源原本就是不充足的,拥有更大的内存范围是没有多大意义的。

    稳定性

    • 进程间不会互相影响,而线程间可能出现同步或其它问题,导致线程异常,单线程出问题会直接导致整个程序出问题。

    扩展性

    • 多进程编程、调试可以相互独立,相对于多线程不会互相影响,因此也更简单,方便。
    • 多进程适合于多核、多机分别式,如果一台机器不够,扩展到多台机器比较简单;而多线程适合于单机多核分布式。

    个人总结

    • 类似嵌入式平台下C和C++的选择,如果追求性能,将性能放第一位,开发效率放第二位,可采用单进程多线程架构;如果程序复杂度较高,并且追求开发效率和稳定性,性能放第二位,资源充裕,可采用多进程多线程架构。
    • 在嵌入式平台上内存等资源都是不充裕的,即使是对单个进程而言,因此使用多进程来占用更多的资源在嵌入式平台是无意义的,但是多进程更具有独立性,对开发人员也更友好。
    • 使用多进程模型,需要使用到进程通信,但是进程通信相对于同进程通信更为麻烦,需要有能满足条件的进程通信模块(成熟、功能强大并且使用简单),在嵌入式平台,只有少量进程通信框架,大部分需要自主实现,Linux基本机制的简单使用不满足复杂需求,因此在嵌入式平台,大部分中小公司项目使用的是单进程模型。

    功能划分

    1. 需要频繁创建和销毁的功能优先用线程。
    2. 需要进行大量计算的功能(CPU密集型)优先使用线程,例如:常见的图像处理、算法处理,要耗费很多CPU,不适合频繁切换,以及在数据通信上花费资源,这种情况下线程是最合适的。
    3. 强相关的功能适合于存在于单进程中的多线程,弱相关的处理,较为独立的功能适合于使用多进程。
    展开全文
  • nodejs多进程架构

    千次阅读 2017-08-21 10:07:24
    cluster原理, node多进程架构

    熟悉node的应该都知道cluster模块,下述提及的问题,cluster模块都已经解决。在我们的项目中直接使用cluster即可。详细的cluster用法请参照官方文档。本文章从原理方面解释了node多进程架构以及cluster部分原理,

    nodejs是单线程,不能充分利用多核cpu资源,因此要启动多进程,每个进程利用一个CPU,实现多核CPU利用。

    一. 共有如下三种方案:

    方案1.开启多个进程,每个进程绑定不同的端口,主进程对外接受所有的网络请求,再将这些请求分别代理到不同的端口的进程上,通过代理可以避免端口不能重复监听的问题,甚至可以再代理进程上做适当的负载均衡,由于进程每接收到一个连接,将会用掉一个文件描述符,因此代理方案中客户端连接到代理进程,代理进程连接到工作进程的过程需要用掉两个文件描述符,操作系统的文件描述符是有限的,代理方案浪费掉一倍数量的文件描述符的做法影响了系统的扩展能力。

    方案2.作为一种改进,父进程创建socket,并且bind、listen后,通过fork创建多个子进程,通过send方法给每个子进程传递这个socket,子进程调用accpet开始监听等待网络连接。demo如下

    // master.js
    var fork =require('child_process').fork;
    var cpus =require('os').cpus();
    var server =require('net').createServer()
    server.listen(1337);
    for(vari=0;i<cpus.length;i++){
      var worker = fork(./worker.js);
      worker.send('server', server);
    }

    // worker.js
    var http =require('http')
    var server =http.createServer(function(req,res){
      res.writeHead(200, {'Content-Type':'text/plain'});
      res.end('handled by child, pid is ' +process.pid +'\n')
    })
    process.on('message',function(m,tcp){
      if(m ==='server') {
        tcp.on('connection',function(socket){
          server.emit('connection',socket);
        })
      }
    })

    这个时候有多个进程同时等待网络的连接事件,当这个事件发生时,这些进程被同时唤醒,就会产生“惊群问题”。我们知道进程被唤醒,需要进行内核重新调度,这样每个进程同时去响应这一个事件,而最终只有一个进程能处理事件成功,其他的进程在处理该事件失败后重新休眠或其他,浪费性能。

    而且这时采用的是操作系统的抢占式策略,谁抢到谁服务,一般而言这是公平的,各个进程可以根据自己的繁忙度来进行抢占,但对于node来说,需要分清他的繁忙度是由CPU,I/O两部分构成的,影响抢占的是CPU的繁忙度,对于不同的业务可能存在I/O繁忙,而CPU较为空闲的情况,这可能造成某个进程抢到较多请求,形成负载不均衡的情况。

    方案3.为了解决负载均衡以及消除惊群效应,改进是在master调用accpet开始监听等待网络连接,master来控制请求的给予。将获得的连接均衡的传递给子进程。

    改进后的代码

    // master.js
    var fork =require('child_process').fork;
    var cpus =require('os').cpus();
    var server =require('net').createServer()
    var workers = []
    server.listen(1337);
    server.on('connection',function(socket){
      var one_worker =workers.pop();//取出一个worker
      one_worker.send('server',socket);
      workers.unshift(one_worker);//再放回取出的worker
    })
    for(vari=0;i<cpus.length;i++){
      var worker = fork(./worker.js);
      workers.push(worker);
    }

    // worker.js
    var http =require('http')
    var server =http.createServer(function(req,res){
      res.writeHead(200, {'Content-Type':'text/plain'});
      res.end('handled by child, pid is ' +process.pid +'\n')
    })
    process.on('message', function(socket){
      if(m === 'server') {
        server.emit('connection', socket)
      }
    })

    但负责接收socket的master需要重新分配发送socket ,而且仅有一个进程去accept连接,效率会降低

    node官方的cluster模块就是这么实现的,实质是采用了round-robin轮叫调度算法。

    二. 集群稳定之路

    1.自动重启:

    我们在主进程上要加入一些子进程管理的机制,比如在一个子进程挂掉后,要重新启动一个子进程来继续服务

    假设子进程中有未捕获异常发生;

    // worker.js
    process.on('uncaughtException',function(err){
      console.error(err);
      //停止接收新的连接
      worker.close(function(){
      //所有已有连接断开后,退出进程
        process.exit(1)
      })
      //如果存在长连接,断开可能需要较久的时间,要强制退出,
      setTimeout(function(){
        process.exit(1)
      }, 5000);
    })
    主进程中监听每个子进程的exit事件
    // master.js
    var other_work = {};
    var createWorker = function() {
      var worker = fork('./worker.js')
      // 退出时启动新的进程
      worker.on('exit',function(){
        console.log('worker ' +worker.pid +' exited.');
        delete other_work[worker.pid]
        createWorker();
      })
      other_work[worker.pid] = worker;
      console.log('create worker pid: ' +worker.pid)
    }

    上述代码中存在的问题是要等到已有的所有连接断开后进程才退出,在极端的情况下,所有工作进程都停止接收新链接,全处在等待退出状态。但在等到进程完全退出才重启的过程中,所有新来的请求可能存在没有工作进程为新用户服务的场景,这会丢掉大部分请求。

    为此需要改进,在子进程停止接收新链接时,主进程就要fork新的子进程继续服务。为此在工作进程得知要退出时,向主进程主动发送一个自杀信号,然后才停止接收新连接。主进程在收到自杀信号后立即创建新的工作进程。

    worker.js代码改动:

    // worker.js
    process.on('uncaughtException',function(err){
      console.error(err);
      process.send({act: 'suicide'})//自杀信号
      worker.close(function(){
        process.exit(1)
      })
      //如果存在长连接,断开可能需要较久的时间,要强制退出,
      setTimeout(function(){
        process.exit(1)
      }, 5000);
    })
    主进程将重启工作进程的任务,从exit事件的处理函数中转移到message事件的处理函数中
    // master.js
    var other_work = {};
    var createWorker = function() {
      var worker = fork('./worker.js')
      worker.on('message', function(){ 
        if(message.act === 'suicide'){
          createWorker();
        } 
      })
      worker.on('exit',function(){
        console.log('worker ' +worker.pid +' exited.');
        delete other_work[worker.pid]
      })
      other_work[worker.pid] =worker;
      console.log('create worker pid: ' +worker.pid)
    }

    2.限量重启

    工作进程不能无限制的被重启,如果启动的过程中就发生了错误或者启动后接到连接就收到错误,会导致工作进程被频繁重启。所以要加以限制,比如在单位时间内规定只能重启

    多少次,超过限制就触发giveup事件,告知放弃重启工作进程这个重要事件。

    我们引入一个队列来做标记,在每次重启工作进程之间打点判断重启是否过于频繁。在master.js加入如下代码

    //重启次数
    var limit =10;
    //时间单位
    var during =60000;
    var restart = [];
    var isTooFrequently =function() {
      //纪录重启时间
      var time =Date.now()
      var length =restart.push(time);
      if (length >limit) {
        //取出最后10个纪录
        restart = restart.slice(limit * -1)
      }
      return restart.length >=limit &&restart[restart.length -1] -restart[0] <during;
    }
    在createWorker方法最开始部分加入判断

    // 检查是否太过频繁
    if (isTooFrequently()) {
      //触发giveup事件后,不再重启
      process.emit('giveup', length, duiring);
      return;
    }

    giveup事件是比uncaughtException更严重的异常事件,giveup事件表示集群中没有任何进程服务了,十分危险。为了健壮性考虑,我们应在giveup事件中添加重要日志,并让监控系统监视到这个严重错误,进而报警等

    3.disconnect事件

    disconnect事件表示父子进程用于通信的channel关闭了,此时父子进程之间失去了联系,自然是无法传递客户端接收到的连接了。失去联系不表示会退出,worker进程有可能仍然在运行,但此时已经无力接收请求了。所以当master进程收到某个worker disconnect的事件时,先需要kill掉worker,然后再fork一个worker。

    // 在createWorker中添加如下代码
    worker.on('disconnect', function(){
      worker.kill();
      console.log('worker' + worker.pid + 'killed')
      createWorker();
    })
    
    
    
    
    
    
    
    

    三. 实际服务器模型



    nginx就是图中的反向代理服务器,拥有诸多优势,可以做负载均衡和静态资源服务器。后面的两台机器就是我们的nodejs应用服务器集群。

    nginx 的负载均衡是用在多机器环境下的,单机的负载均衡还是要靠cluster 这类模块来做。

    nginx与node应用服务器的对比:nginx是一个高性能的反向代理服务器,要大量并且快速的转发请求,所以不能采用上面第三种方法,原因是仅有一个进程去accept,然后通过消息队列等同步方式使其他子进程处理这些新建的连接,效率会低一些。nginx采用第二种方法,那就依然可能会产生负载不完全均衡和惊群问题。nginx是怎么解决的呢:nginx中使用mutex互斥锁解决这个问题,具体措施有使用全局互斥锁,每个子进程在epoll_wait()之前先去申请锁,申请到则继续处理,获取不到则等待,并设置了一个负载均衡的算法(当某一个子进程的任务量达到总设置量的7/8时,则不会再尝试去申请锁)来均衡各个进程的任务量。具体的nginx如何解决惊群,看这篇文章: http://blog.csdn.net/russell_tao/article/details/7204260

    那么,node应用服务器为什么可以采用方案三呢,我的理解是:node作为具体的应该服务器负责实际处理用户的请求,处理可能包含数据库等操作,不是必须快速的接收大量请求,而且转发到某具体的node单台服务器上的请求较之nginx也少了很多。

    参考文献:

    <深入浅出nodejs>

    http://blog.csdn.net/russell_tao/article/details/7204260

    https://yq.aliyun.com/articles/3068

    https://segmentfault.com/a/1190000004621734

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 浏览器的多进程架构

    2020-05-29 09:34:28
    引用多进程架构的原因:单进程浏览器不稳定、不流畅和不安全 多进程架构组成 浏览器进程(只有一个)。主要负责界面显示、用户交互、子进程管理,同时提供存储等功能 渲染进程(多个)。核心任务是将 HTML、CSS 和 ...

    引用多进程架构的原因:单进程浏览器不稳定、不流畅和不安全
    多进程架构组成

    • 浏览器进程(只有一个)。主要负责界面显示、用户交互、子进程管理,同时提供存储等功能
    • 渲染进程(多个)。核心任务是将 HTML、CSS 和 JavaScript 转换为用户可以与之交互的网页,排版引擎 Blink 和 JavaScript 引擎 V8 都是运行在该进程中,默认情况下,Chrome 会为每个 Tab 标签创建一个渲染进程。出于安全考虑,渲染进程都是运行在沙箱模式下
      • 采用多进程架构的额外好处是可以使用安全沙箱,你可以把沙箱看成是操作系统给进程上了一把锁,沙箱里面的程序可以运行,但是不能在你的硬盘上写入任何数据,也不能在敏感位置读取任何数据,例如你的文档和桌面。Chrome 把插件进程和渲染进程锁在沙箱里面,这样即使在渲染进程或者插件进程里面执行了恶意程序,恶意程序也无法突破沙箱去获取系统权限
    • GPU 进程(一个)。 GPU 的使用初衷是为了实现 3D CSS 的效果,较多网页、Chrome 的 UI 界面都选择采用 GPU 来绘制,这使得 GPU 成为浏览器普遍的需求。最后,Chrome 在其多进程架构上也引入了 GPU 进程
    • 网络进程(一个)。主要负责页面的网络资源加载,之前是作为一个模块运行在浏览器进程里面的,直至最近才独立出来,成为一个单独的进程
    • 插件进程(多个)。主要是负责插件的运行,因插件易崩溃,所以需要通过插件进程来隔离,以保证插件进程崩溃不会对浏览器和页面造成影响

    一个思考

    如果打开了 2个页面,会有几个进程呢
    答:通常情况下会是五个( 1 个网络进程、1 个浏览器进程、1 个 GPU 进程以及 2个渲染进程),但是有很多其他情况:
    1:如果页面里有iframe的话,iframe也会运行在单独的进程中
    2:如果页面里有插件,同样插件也需要开启一个单独的进程
    3:如果你装了扩展的话,扩展也会占用进程
    4:如果2个页面属于同一站点的话,并且从a页面中打开的b页面,那么他们会公用一个渲染进程(同一站点指协议相同且根域名相同)

    展开全文
  • node.js多进程架构

    2019-12-07 15:35:19
    node.js是单进程应用,要充分利用多核cpu的性能,就需要用到多进程架构。 作为web服务器,不能多个进程创建不同的socket文件描述符去accept网络请求, 有经验的同学知道,如果端口被占用了,再跑一个监听该端口的...
  • 无论你是设计高性能的Web应用,还是从事Electron开发,或是从事Node.js扩展C++开发,了解Chrome的多进程架构以及网络流程、页面渲染过程、JavaScript执行流程等知识,是很有必要的。这一章,我在这里为大家浅析一下...
  • 关于多进程架构的一种思路 为什么要搞多进程架构? 每一个进程都有自己的独立空间,一个进程崩溃,不会影响其他的进程。因此多进程架构的程序,它的健壮性大大加强。 单进程多线程的程序,经常会遇到因为主线程...
  • Chromium多进程架构简要介绍和学习计划

    万次阅读 热门讨论 2015-08-10 01:04:40
    Chromium以多进程架构著称,它主要包含四类进程,分别是Browser进程、Render进程、GPU进程和Plugin进程。之所以要将Render进程、GPU进程和Plugin进程独立出来,是为了解决它们的不稳定性问题。也就是说,Render进程...
  • 多进程架构设计

    2014-06-28 21:26:35
    多进程架构设计   第一篇 网络服务  现实生活中,网络通信的例子很多,例如,我们用浏览器打开一个网页,这个浏览器程序就向服务器发送一个HTTP请求,服务器收到这个请求后,经一番内部的逻辑处理,就将结果...
  •   MMORPG为了满足单服承载更多玩家的需求,往往会采用多进程架构,即k个GameServer负责游戏逻辑以及一个WorldServer负责全局逻辑,如果单服承载n个玩家,则每个GameServer承载n/k个玩家。帮会等公共数据均在World...
  • 打开macbook的 Activity Monitor可以看到,chrome浏览器启动会会创建很多进程你可以点击 Chrome 浏览器右上角的“选项”菜单,选择“更多工具”子菜单,点击“任务管理器”chrome浏览器的多进程架构随着 Chrome 的...
  • Chromium浏览器的多进程架构

    千次阅读 2014-03-13 22:09:05
    本文主要介绍Chromium的多进程架构,在原文的基础上添加里自己的一些理解。 为什么引入多进程架构? 在Chromium引入多进程架构之前,当前流行的浏览器都采用单进程实现,例如FireFox,IE,Safari等,浏览器所有的...
  • [Chromium中文文档]Chromium多进程架构

    千次阅读 2016-03-13 13:51:45
    Chromium多进程架构
  • Chromium的多进程架构

    千次阅读 2014-03-01 16:47:36
    Chromium的多进程架构 Problem It's nearly impossible to build arendering engine that never crashes or hangs. It's also nearly impossible tobuild a rendering engine that is perfectly secure. In some ...
  • 为什么引入多进程架构? 在Chromium引入多进程架构之前,当前流行的浏览器都采用单进程实现,例如FireFox,IE,Safair等,浏览器所有的标签页都运行在同一个进程中,当某个标签页崩溃时(可能由于渲染引擎的缺陷...
  • chromium多进程架构

    2019-08-28 16:26:14
    render process, 这个是个blink或者webkit的进程,只是parse, layout 浏览器进程,提供network stack和file IO。 PLUG IN 的进程 GPU 进程 render process跟浏览器进程有交互,会给plug in 进程发指令,会通过...
  • Chrom 的多进程架构

    千次阅读 2012-08-08 21:40:54
    多进程架构(原文地址:http://www.chromium.org/developers/design-documents/multi-process-architecture ) 这篇文档描述了 Chromium 的上层架构。 a、问题所在 几乎没可能建立一个永远不崩溃或挂机的...
  • 浏览器多进程架构

    2018-11-16 01:54:00
    跟很多多线程浏览器不一样,chrome使用多个进程来隔离不同的标签页,因此打开一个标签页,就等于是开了一个新的进程,当然,...多进程:类似于一个工厂,每个工厂有每个工厂自己做的时间,互不影响 多线程:类似于...
  • 在这篇文章中(Part 1),我将介绍一些核心的计算机术语和 Chrome 的多进程架构。友情提示:如果你对 CPU/GPU 的概念很熟悉的话,可以直接去看浏览器架构的部分。CPU 和 GPU为了更好的了解浏览器的运行环境,我们首先...
  • 最新的 Chrome 进程架构图 从图中可以看出,最新的 Chrome 浏览器包括:1 个浏览器(Browser)主进程、1 个 GPU 进程、1 个网络(NetWork)进程、个渲染进程和个插件进程。 浏览器进程。主要负责界面显示、...
  • 为了应对浏览器经常出现崩溃的现象,现在很多浏览器厂商都采用了多进程标签浏览的概念,其中包括主的IE8、Chrome、Firefox浏览器,而众多基于WebKit的浏览器在苹果发布WebKit2内核以后已经将可以后采用多进程标签...
  • Firefox 自 8 月发布的 v48 起支持多进程架构 E10S(Electrolysis),但 E10S 当时未对所有用户启用,而是逐步扩大启用范围,以确保不会出现问题。 Mozilla 官方博客现在公布了多进程Firefox的近期计划:如果进展...
  • Chromium以多进程架构著称,它主要包含四类进程,分别是Browser进程、Render进程、GPU进程和Plugin进程。之所以要将Render进程、GPU进程和Plugin进程独立出来,是为了解决它们的不稳定性问题。也就是说,Render进程...
  • 本文档从high-level的角度描述Chromium的多进程架构。 问题 要构建一个决不崩溃或挂起的渲染引擎几乎是不可能的。同样的,要构建一个100%安全的渲染引擎也是不可能的。 从某些角度来看,当今的web浏览器有点类似...
  • 浏览器多进程架构的反思

    千次阅读 2010-02-12 13:29:00
    浏览器采用多进程架构的有:chrome、maxthon3等。采用多进程架构到底有何益处:1.将插件放到单独的进程 * 插件崩溃不会影响到浏览操作,该目标看起来容易实现,实际效果受实际处理逻辑限制。 * NP插件的接口非常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,243
精华内容 2,097
关键字:

多进程架构