精华内容
下载资源
问答
  • VUE中methods watchcompute的区别和联系

    万次阅读 多人点赞 2018-05-14 16:33:56
    》 首先要说,methods,watchcomputed都是以函数为基础的,但各自却都不同 而从作用机制和性质上看,methodswatch/computed不太一样,所以我接下来的介绍主要有两个对比:1.methods(watch/computed)的对比2....

    从作用机制和性质上看待methods,watch和computed的关系

    图片标题:《他三个是啥子关系呢?》

     

    首先要说,methods,watch和computed都是以函数为基础的,但各自却都不同 

    而从作用机制和性质上看,methods和watch/computed不太一样,所以我接下来的介绍主要有两个对比:

    1.methods和(watch/computed)的对比

    2.watch和computed的对比

    作用机制上

    1.watch和computed都是以Vue的依赖追踪机制为基础的,它们都试图处理这样一件事情:当某一个数据(称它为依赖数据)发生变化的时候,所有依赖这个数据的“相关”数据“自动”发生变化,也就是自动调用相关的函数去实现数据的变动。

    2.对methods:methods里面是用来定义函数的,很显然,它需要手动调用才能执行。而不像watch和computed那样,“自动执行”预先定义的函数

     【总结】:methods里面定义的函数,是需要主动调用的,而和watch和computed相关的函数,会自动调用,完成我们希望完成的作用

    从性质上看

    1.methods里面定义的是函数,你显然需要像"fuc()"这样去调用它(假设函数为fuc)

    2.computed是计算属性,事实上和和data对象里的数据属性是同一类的(使用上),

    例如:

    1
    2
    3
    computed:{
      fullName: function () { return this.firstName + lastName }
    }

    你在取用的时候,用this.fullName去取用,就和取data一样(不要当成函数调用!!)

    3.watch:类似于监听机制+事件机制:

    例如:

    1
    2
    3
    watch: {
      firstName: function (val) { this.fullName = val + this.lastName }
    }

    firstName的改变是这个特殊“事件”被触发的条件,而firstName对应的函数就相当于监听到事件发生后执行的方法

    watch和computed的对比

    说了这么多,下面先对watch和computed

    首先它们都是以Vue的依赖追踪机制为基础的,它们的共同点是:都是希望在依赖数据发生改变的时候,被依赖的数据根据预先定义好的函数,发生“自动”的变化

    我们当然可以自己写代码完成这一切,但却很可能造成写法混乱,代码冗余的情况。Vue为我们提供了这样一个方便的接口,统一规则

    但watch和computed也有明显不同的地方:

    watch和computed各自处理的数据关系场景不同

    1.watch擅长处理的场景:一个数据影响多个数据

    2.computed擅长处理的场景:一个数据受多个数据影响

    watch擅长处理的场景:一个数据影响多个数据

     

    (具体的看上图就ok,这里不再赘述)

    对于watch,我们先从一个场景说起

    在《海贼王》里面,主角团队的名称叫做:“草帽海贼团”

    所以我们把船员依次称为:

    草帽海贼团索隆,草帽海贼团娜美,以此类推。。。

    我们希望:当船团名称发生变更的时候,这艘船上所有船员的名字一起变更!!

    例如:

    有一天,船长路飞为了加强团队建设,弘扬海贼文化,决定“草帽海贼团”改名为“橡胶海贼团”(路飞是橡胶恶魔果实能力者)

    我们代码如下: 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    var vm = new Vue({
     el: '#app',
     /*
      data选项中的数据:
      1.haiZeiTuan_Name --> 海贼团名称
      2.船员的名称 = 海贼团名称(草帽海贼团) + 船员名称(例如索隆)
      
      这些数据里存在这种关系:
      (多个)船员名称数据 --> 依赖于 --> (1个)海贼团名称数据
      一个数据变化 ---> 多个数据全部变化
     */
     data: {
      haiZeiTuan_Name: '草帽海贼团',
      suoLong: '草帽海贼团索隆',
      naMei: '草帽海贼团娜美',
      xiangJiShi: '草帽海贼团香吉士'
     },
     /*
      在watch中,一旦haiZeiTuan_Name(海贼团名称)发生改变
      data选项中的船员名称全部会自动改变 (suoLong,naMei,xiangJiShi)
      并把它们打印出来
     */
     watch: {
      haiZeiTuan_Name: function (newName) {
       this.suoLong = newName + '索隆'
       this.naMei = newName + '娜美'
       this.xiangJiShi = newName + '香吉士'
       console.log(this.suoLong)
       console.log(this.naMei)
       console.log(this.xiangJiShi)
      }
     }
    })
      
    // 更改watch选项中监控的主数据
    vm.haiZeiTuan_Name = '橡胶海贼团'

    demo:

    于是船员们的称号前缀都被统一修改了!(原本是“草帽海贼团”)

    但是我们的路飞船长又突发奇想:我这么喜欢吃肉,干脆我们叫做“肉肉海贼团”好了吧!

    我们把最下面的代码改为:

    1
    2
    // 更改watch选项中监控的主数据
    vm.haiZeiTuan_Name = '肉肉海贼团'

    demo:

     

    computed擅长处理的场景:一个数据受多个数据影响

     

    我们再从一个场景说起

    路飞的全名叫做:蒙奇-D-路飞,他想成为海贼王,但路飞的爷爷卡普(海军英雄)因此感到非常恼怒,于是把“路飞”改成了叫“海军王”,希望他能改变志向

    代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    var vm = new Vue({
     el: '#app',
     /*
      data选项中的数据:firstName,secName,thirdName
      computed监控的数据:lufei_Name
      两者关系: lufei_Name = firstName + secName + thirdName
      所以等式右边三个数据任一改变,都会直接修改 lufei_Name
     */
     data: {
      // 路飞的全名:蒙奇·D·路飞
      firstName: '蒙奇',
      secName: 'D',
      thirdName: '路飞'
     },
     computed: {
      luFei_Name: function () {
       return this.firstName + this.secName + this.thirdName
      }
     }
    })
      
    // 将“路飞”改为“海军王”
    vm.thirdName = '海军王'
    // 打印路飞的全名
    console.log(vm.luFei_Name)

    demo:

     

     但是:

    有一天,路飞的逗逼爷爷卡普,一不小心发现可能把族谱搞错了,实际上,他们不是“D”之一族,而是“H”一族,也就是说,“蒙奇-D-路飞”可能要叫做“蒙奇-H-路飞”了

    将最后一段代码改为如下:

    1
    2
    3
    4
    // 将“D”改为“H”
    vm.secName = 'H'
    // 打印路飞的全名
    console.log(vm.luFei_Name)

    demo:

     

    methods不处理数据逻辑关系,只提供可调用的函数

    相比于watch/computed,methods不处理数据逻辑关系,只提供可调用的函数 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    new Vue({
     el: '#app',
     template: '<div id="app"><p>{{ say() }}</p></div>',
     methods: {
      say: function () {
       return '我要成为海贼王'
      }
     }
    })

    从功能的互补上看待methods,watch和computed的关系

      

    在很多时候,computed是用来处理你使用watch和methods的时候无法处理,或者是处理起来并不太恰当的情况的

    利用computed处理methods存在的重复计算情况

    1.methods里面的函数就是一群“耿直Boy”,如果有其他父函数调用它,它会每一次都“乖乖”地执行并返回结果,即使这些结果很可能是相同的,是不需要的

    2.而computed是一个“心机Boy”,它会以Vue提供的依赖追踪系统为基础,只要依赖数据没有发生变化,computed就不会再度进行计算

    例子: 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    new Vue({
     el: '#app',
     // 设置两个button,点击分别调用getMethodsDate,getComputedDate方法
     template: '<div id="app"><button @click="getMethodsDate">methods</button><button @click="getComputedDate">computed</button></div>',
     methods: {
      getMethodsDate: function () {
       alert(new Date())
      },
      // 返回computed选项中设置的计算属性——computedDate
      getComputedDate: function () {
       alert(this.computedDate)
      }
     },
     computed: {
      computedDate: function () {
       return new Date()
      }
     }

     第一次点击methods按钮:

     

    第二次点击methods按钮:


    注意两次点击methods返回的时间是不同的!!

     第一次点击computed按钮:

     

    第二次点击computed按钮:

     

     注意两次点击computed返回的时间是相同的!!

    1.两次点击methods返回的时间是不同的

    2.注意两次点击computed返回的时间是相同的

     【注意】为什么两次点击computed返回的时间是相同的呢?new Date()不是依赖型数据(不是放在data等对象下的实例数据),所以computed只提供了缓存的值,而没有重新计算

     只有符合:1.存在依赖型数据 2.依赖型数据发生改变这两个条件,computed才会重新计算。 

    而methods下的数据,是每次都会进行计算的 

    利用computed处理watch在特定情况下代码冗余的现象,简化代码

     

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    new Vue({
     el: '#app',
     data: {
      fullName: '彭湖湾',
      firstName: '彭',
      secName: '湖',
      thirdName: '湾'
     },
     // watch中的代码显然是同类型,重复的,它并不简洁,也不优雅
     watch: {
      firstName: function (newValue) {
       this.fullName = newValue + this.secName + this.thirdName
       console.log(this.fullName)
      },
      secName: function (newValue) {
       this.fullName = this.firstName + newValue + this.thirdName
       console.log(this.fullName)
      },
      thirdName: function (newValue) {
       this.fullName = this.firstName + this.secName + newValue
       console.log(this.fullName)
      }
     }
    })

    watch中的代码显然是同类型,重复的,它并不简洁,也不优雅,所以我们可以把它变成这样

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    new Vue({
     el: '#app',
     data: {
      fullName: '彭湖湾',
      firstName: '彭',
      secName: '湖',
      thirdName: '湾'
     },
     // 对watch中的代码进行重构,实现同样效果
     computed: function () {
      this.fullName = this.firstName + this.secName + this.thirdName
      console.log(this.fullName)
     }
    })

    转自:http://www.jb51.net/article/120073.htm

    展开全文
  • 进程线程的定义、区别联系

    万次阅读 多人点赞 2016-06-26 16:52:14
    进程:指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令、数据堆栈等组成的,是一个能独立运行的活动实体。  注意,进程一般有三个状态:就绪状态、执行状态等待状态【或称阻塞状态】;进程...
    一、进程

    进程:指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令、数据和堆栈等组成的,是一个能独立运行的活动实体。

        注意,进程一般有三个状态:就绪状态、执行状态和等待状态【或称阻塞状态】;进程只能由父进程建立,系统中所有的进程形成一种进程树的层次体系;挂起命令可由进程自己和其他进程发出,但是解除挂起命令只能由其他进程发出。

    进程控制块(PCB):PCB不但可以记录进程的属性信息,以便操作系统对进程进行控制和管理,而且PCB标志着进程的存在,操作系统根据系统中是否有该进程的进程控制块PCB而知道该进程存在与否。系统建立进程的同时就建立该进程的PCB,在撤销一个进程时,也就撤销其PCB,故进程的PCB对进程来说是它存在的具体的物理标志和体现。一般PCB包括以下三类信息:进程标识信息;处理器状态信息;进程控制信息。

        由程序段、相关的数据段和PCB三部分构成了进程实体(又称进程印像),一般,我们把进程实体就简称为进程。

    进程的特征:
    1.动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的。
    2.并发性:任何进程都可以同其他进程一起并发执行。
    3.独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位。
    4.异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进。


    二、线程


    线程:线程是进程中的一个实体,作为系统调度和分派的基本单位。
    Linux下的线程看作轻量级进程。


    线程的性质:
    1.线程是进程内的一个相对独立的可执行的单元。若把进程称为任务的话,那么线程则是应用中的一个子任务的执行。
    2.由于线程是被调度的基本单元,而进程不是调度单元。所以,每个进程在创建时,至少需要同时为该进程创建一个线程。即进程中至少要有一个或一个以上的线程,否则该进程无法被调度执行。
    3.进程是被分给并拥有资源的基本单元。同一进程内的多个线程共享该进程的资源,但线程并不拥有资源,只是使用他们。
    4.线程是操作系统中基本调度单元,因此线程中应包含有调度所需要的必要信息,且在生命周期中有状态的变化。
    5.由于共享资源【包括数据和文件】,所以线程间需要通信和同步机制,且需要时线程可以创建其他线程,但线程间不存在父子关系。


    多线程使用的情形:前台和后台工作情况;异步处理工作情况;需要加快执行速度情况;组织复杂工作的情况;同时有多个用户服务请求的情况等。
     
    线程机制的优点:
    多线程运行在同一个进程的相同的地址空间内,和采用多进程相比有以下优点:
    1.创建和撤销线程的开销较之进程要少。创建线程时只需要建立线程控制表相应的表目,或有关队列,而创建进程时,要创建PCB表和初始化,进入有关进程队列,建立它的地址空间和所需资源等。
    2.CPU在线程之间开关时的开销远比进程要少得多。因开关线程都在同一地址空间内,只需要修改线程控制表或队列,不涉及地址空间和其他工作。
    3.线程机制也增加了通讯的有效性。进程间的通讯往往要求内核的参与,以提供通讯机制和保护机制,而线程间的通讯是在同一进程的地址空间内,共享主存和文件,无需内核参与。


    三、进程和线程的区别


    (1)调度:
            在传统的操作系统中,CPU调度和分派的基本单位是进程。而在引入线程的操作系统中,则把线程作为CPU调度和分派的基本单位,进程则作为资源拥有的基本单位,从而使传统进程的两个属性分开,线程编程轻装运行,这样可以显著地提高系统的并发性。同一进程中线程的切换不会引起进程切换,从而避免了昂贵的系统调用,但是在由一个进程中的线程切换到另一进程中的线程,依然会引起进程切换。
     
    (2)并发性:
          在引入线程的操作系统中,不仅进程之间可以并发执行,而且在一个进程中的多个线程之间也可以并发执行,因而使操作系统具有更好的并发性,从而更有效地提高系统资源和系统的吞吐量。例如,在一个为引入线程的单CPU操作系统中,若仅设置一个文件服务进程,当它由于某种原因被封锁时,便没有其他的文件服务进程来提供服务。在引入线程的操作系统中,可以在一个文件服务进程设置多个服务线程。当第一个线程等待时,文件服务进程中的第二个线程可以继续运行;当第二个线程封锁时,第三个线程可以继续执行,从而显著地提高了文件服务的质量以及系统的吞吐量。


    (3)拥有资源:
          不论是引入了线程的操作系统,还是传统的操作系统,进程都是拥有系统资源的一个独立单位,他可以拥有自己的资源。一般地说,线程自己不能拥有资源(也有一点必不可少的资源),但它可以访问其隶属进程的资源,亦即一个进程的代码段、数据段以及系统资源(如已打开的文件、I/O设备等),可供同一个进程的其他所有线程共享。


    (4)独立性:
            在同一进程中的不同线程之间的独立性要比不同进程之间的独立性低得多。这是因为

    为防止进程之间彼此干扰和破坏,每个进程都拥有一个独立的地址空间和其它资源,除了共享全局变量外,不允许其它进程的访问。但是同一进程中的不同线程往往是为了提高并发性以及进行相互之间的合作而创建的,它们共享进程的内存地址空间和资源,如每个线程都可以访问它们所属进程地址空间中的所有地址,如一个线程的堆栈可以被其它线程读、写,甚至完全清除。


    (5)系统开销:

           由于在创建或撤销进程时,系统都要为之分配或回收资源,如内存空间、I/O设备等。因此,操作系统为此所付出的开销将显著地大于在创建或撤消线程时的开销。类似的,在进程切换时,涉及到整个当前进程CPU环境的保存环境的设置以及新被调度运行的CPU环境的设置,而线程切换只需保存和设置少量的寄存器的内容,并不涉及存储器管理方面的操作,可见,进程切换的开销也远大于线程切换的开销。此外,由于同一进程中的多个线程具有相同的地址空间,致使他们之间的同步和通信的实现也变得比较容易。在有的系统中,现成的切换、同步、和通信都无需操作系统内核的干预。


    (6)支持多处理机系统:
           在多处理机系统中,对于传统的进程,即单线程进程,不管有多少处理机,该进程只能运行在一个处理机上。但对于多线程进程,就可以将一个进程中的多个线程分配到多个处理机上,使它们并行执行,这无疑将加速进程的完成。因此,现代处理机OS都无一例外地引入了多线程。

    展开全文
  • 程序,进程,线程的区别和联系

    万次阅读 多人点赞 2018-08-26 22:27:18
    进程程序区别和联系表现在以下方面: 1)程序只是一组指令的有序集合,它本身没有任何运行的含义,它只是一个静态的实体。而进程则不同,它是程序在某个数据集上的执行。进程是一个动态的实体,它有自己的生命周期...

    进程和程序区别和联系表现在以下方面:
    1)程序只是一组指令的有序集合,它本身没有任何运行的含义,它只是一个静态的实体。而进程则不同,它是程序在某个数据集上的执行。进程是一个动态的实体,它有自己的生命周期。它因创建而产生,因调度而运行,因等待资源或事件而被处于等待状态,因完成任务而被撤消。反映了一个程序在一定的数据集上运行的全部动态过程。
    2)进程和程序并不是一一对应的,一个程序执行在不同的数据集上就成为不同的进程,可以用进程控制块来唯一地标识每个进程。而这一点正是程序无法做到的,由于程序没有和数据产生直接的联系,既使是执行不同的数据的程序,他们的指令的集合依然是一样的,所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说,一个进程肯定有一个与之对应的程序,而且只有一个。而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。
    3)进程还具有并发性和交往性,这也与程序的封闭性不同。
    ----------------------------------------------------------------------------------------------
    进程和线程都是由操作系统所体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于:
    简而言之,一个程序至少有一个进程,一个进程至少有一个线程。
    线程的划分尺度小于进程,使得多线程程序的并发性高。
    另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。
    线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
    从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
    进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。
    线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
    一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。
    ----------------------------------------------------------------------------------------------
    进程和线程的区别 
    说法一:进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。
    线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
    一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。

     
    说法二:进程和线程都是由操作系统所体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于:
    简而言之,一个程序至少有一个进程,一个进程至少有一个线程.。
    线程的划分尺度小于进程,使得多线程程序的并发性高。
    另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。
    线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
    从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

     
    说法三:多线程共存于应用程序中是现代操作系统中的基本特征和重要标志。用过UNIX操作系统的读者知道进程,在UNIX操作系统中,每个应用程序的执行都在操作系统内核中登记一个进程标志,操作系统根据分配的标志对应用程序的执行进行调度和系统资源分配,但进程和线程有什么区别呢?
    进程和线程都是由操作系统所体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于:
    进程(Process)是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例,进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统对应用程序进程的控制来实现的。 
    C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后,提交给计算机处理器运行。这时,处在可执行状态中的应用程序称为进程。从用户角度来看,进程是应用程序的一个执行过程。从操作系统核心角度来看,进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位,是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中,而进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括: 
    ●进程在执行过程中有内存单元的初始入口点,并且进程存活过程中始终拥有独立的内存地址空间; 
    ●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型; 
    ●从应用程序进程在执行过程中向CPU发出的运行指令形式不同,可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令。 
    在Unix操作系统启动过程中,系统自动创建swapper、init等系统进程,用于管理内存资源以及对用户进程进行调度等。在Unix环境下无论是由操作系统创建的进程还要由应用程序执行创建的进程,均拥有唯一的进程标识(PID)。 


    说法四:应用程序在执行过程中存在一个内存空间的初始入口点地址、一个程序执行过程中的代码执行序列以及用于标识进程结束的内存出口点地址,在进程执行过程中的每一时间点均有唯一的处理器指令与内存单元地址相对应。 
    Java语言中定义的线程(Thread)同样包括一个内存入口点地址、一个出口点地址以及能够顺序执行的代码序列。但是进程与线程的重要区别在于线程不能够单独执行,它必须运行在处于活动状态的应用程序进程中,因此可以定义线程是程序内部的具有并发性的顺序代码流。 
    Unix操作系统和Microsoft Windows操作系统支持多用户、多进程的并发执行,而Java语言支持应用程序进程内部的多个执行线程的并发执行。多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。但是多线程并不意味着多个用户进程在执行,操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程,子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间,但保持每个线程拥有独立的执行堆栈和程序执行上下文(Context)。 
    基于上述区别,线程也可以称为轻型进程 (Light Weight Process,LWP)。不同线程间允许任务协作和数据交换,使得在计算机系统资源消耗等方面非常廉价。 
    线程需要操作系统的支持,不是所有类型的计算机都支持多线程应用程序。Java程序设计语言将线程支持与语言运行环境结合在一起,提供了多任务并发执行的能力。这就好比一个人在处理家务的过程中,将衣服放到洗衣机中自动洗涤后将大米放在电饭锅里,然后开始做菜。等菜做好了,饭熟了同时衣服也洗好了。 
    需要注意的是:在应用程序中使用多线程不会增加 CPU 的数据处理能力。只有在多CPU 的计算机或者在网络计算体系结构下,将Java程序划分为多个并发执行线程后,同时启动多个线程运行,使不同的线程运行在基于不同处理器的Java虚拟机中,才能提高应用程序的执行效率。

    以上参考链接:https://blog.csdn.net/u011156212/article/details/12617999

    首先来一句概括的总论:进程和线程都是一个时间段的描述,是CPU工作时间段的描述。

    下面细说背景
    CPU+RAM+各种资源(比如显卡,光驱,键盘,GPS, 等等外设)构成我们的电脑,但是电脑的运行,实际就是CPU和相关寄存器以及RAM之间的事情。

    一个最最基础的事实:CPU太快,太快,太快了,寄存器仅仅能够追的上他的脚步,RAM和别的挂在各总线上的设备完全是望其项背。那当多个任务要执行的时候怎么办呢?轮流着来?或者谁优先级高谁来?不管怎么样的策略,一句话就是在CPU看来就是轮流着来。

    一个必须知道的事实:执行一段程序代码,实现一个功能的过程介绍 ,当得到CPU的时候,相关的资源必须也已经就位,就是显卡啊,GPS啊什么的必须就位,然后CPU开始执行。这里除了CPU以外所有的就构成了这个程序的执行环境,也就是我们所定义的程序上下文。当这个程序执行完了,或者分配给他的CPU执行时间用完了,那它就要被切换出去,等待下一次CPU的临幸。在被切换出去的最后一步工作就是保存程序上下文,因为这个是下次他被CPU临幸的运行环境,必须保存。

    串联起来的事实:前面讲过在CPU看来所有的任务都是一个一个的轮流执行的,具体的轮流方法就是:先加载程序A的上下文,然后开始执行A,保存程序A的上下文,调入下一个要执行的程序B的程序上下文,然后开始执行B,保存程序B的上下文。。。

    ========= 重要的东西出现了========

    进程和线程就是这样的背景出来的,两个名词不过是对应的CPU时间段的描述,名词就是这样的功能。

    • 进程就是包括上下文切换的程序执行时间总和 = CPU加载上下文+CPU执行+CPU保存上下文

    线程是什么呢?
    进程的颗粒度太大,每次都要有上下的调入,保存,调出。如果我们把进程比喻为一个运行在电脑上的软件,那么一个软件的执行不可能是一条逻辑执行的,必定有多个分支和多个程序段,就好比要实现程序A,实际分成 a,b,c等多个块组合而成。那么这里具体的执行就可能变成:

    程序A得到CPU =》CPU加载上下文,开始执行程序A的a小段,然后执行A的b小段,然后再执行A的c小段,最后CPU保存A的上下文。

    这里a,b,c的执行是共享了A的上下文,CPU在执行的时候没有进行上下文切换的。这里的a,b,c就是线程,也就是说线程是共享了进程的上下文环境,的更为细小的CPU时间段。

    到此全文结束,再一个总结:


    进程和线程都是一个时间段的描述,是CPU工作时间段的描述,不过是颗粒大小不同。

    作者:zhonyong
    链接:https://www.zhihu.com/question/25532384/answer/81152571
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


    一、进程

    进程:指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令、数据和堆栈等组成的,是一个能独立运行的活动实体。

        注意,进程一般有三个状态:就绪状态、执行状态和等待状态【或称阻塞状态】;进程只能由父进程建立,系统中所有的进程形成一种进程树的层次体系;挂起命令可由进程自己和其他进程发出,但是解除挂起命令只能由其他进程发出。

     

    进程控制块(PCB):PCB不但可以记录进程的属性信息,以便操作系统对进程进行控制和管理,而且PCB标志着进程的存在,操作系统根据系统中是否有该进程的进程控制块PCB而知道该进程存在与否。系统建立进程的同时就建立该进程的PCB,在撤销一个进程时,也就撤销其PCB,故进程的PCB对进程来说是它存在的具体的物理标志和体现。一般PCB包括以下三类信息:进程标识信息;处理器状态信息;进程控制信息。

        由程序段、相关的数据段和PCB三部分构成了进程实体(又称进程印像),一般,我们把进程实体就简称为进程。

    进程的特征:
    1.动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的。
    2.并发性:任何进程都可以同其他进程一起并发执行。
    3.独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位。
    4.异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进。


    二、线程


    线程:线程是进程中的一个实体,作为系统调度和分派的基本单位。Linux下的线程看作轻量级进程。


    线程的性质:
    1.线程是进程内的一个相对独立的可执行的单元。若把进程称为任务的话,那么线程则是应用中的一个子任务的执行。
    2.由于线程是被调度的基本单元,而进程不是调度单元。所以,每个进程在创建时,至少需要同时为该进程创建一个线程。即进程中至少要有一个或一个以上的线程,否则该进程无法被调度执行。
    3.进程是被分给并拥有资源的基本单元。同一进程内的多个线程共享该进程的资源,但线程并不拥有资源,只是使用他们。
    4.线程是操作系统中基本调度单元,因此线程中应包含有调度所需要的必要信息,且在生命周期中有状态的变化。
    5.由于共享资源【包括数据和文件】,所以线程间需要通信和同步机制,且需要时线程可以创建其他线程,但线程间不存在父子关系。


    多线程使用的情形:前台和后台工作情况;异步处理工作情况;需要加快执行速度情况;组织复杂工作的情况;同时有多个用户服务请求的情况等。
     
    线程机制的优点:
    多线程运行在同一个进程的相同的地址空间内,和采用多进程相比有以下优点:
    1.创建和撤销线程的开销较之进程要少。创建线程时只需要建立线程控制表相应的表目,或有关队列,而创建进程时,要创建PCB表和初始化,进入有关进程队列,建立它的地址空间和所需资源等。
    2.CPU在线程之间开关时的开销远比进程要少得多。因开关线程都在同一地址空间内,只需要修改线程控制表或队列,不涉及地址空间和其他工作。
    3.线程机制也增加了通讯的有效性。进程间的通讯往往要求内核的参与,以提供通讯机制和保护机制,而线程间的通讯是在同一进程的地址空间内,共享主存和文件,无需内核参与。


    三、进程和线程的区别


    (1)调度:
            在传统的操作系统中,CPU调度和分派的基本单位是进程。而在引入线程的操作系统中,则把线程作为CPU调度和分派的基本单位,进程则作为资源拥有的基本单位,从而使传统进程的两个属性分开,线程编程轻装运行,这样可以显著地提高系统的并发性。同一进程中线程的切换不会引起进程切换,从而避免了昂贵的系统调用,但是在由一个进程中的线程切换到另一进程中的线程,依然会引起进程切换。
     
    (2)并发性:
          在引入线程的操作系统中,不仅进程之间可以并发执行,而且在一个进程中的多个线程之间也可以并发执行,因而使操作系统具有更好的并发性,从而更有效地提高系统资源和系统的吞吐量。例如,在一个为引入线程的单CPU操作系统中,若仅设置一个文件服务进程,当它由于某种原因被封锁时,便没有其他的文件服务进程来提供服务。在引入线程的操作系统中,可以在一个文件服务进程设置多个服务线程。当第一个线程等待时,文件服务进程中的第二个线程可以继续运行;当第二个线程封锁时,第三个线程可以继续执行,从而显著地提高了文件服务的质量以及系统的吞吐量。


    (3)拥有资源:
          不论是引入了线程的操作系统,还是传统的操作系统,进程都是拥有系统资源的一个独立单位,他可以拥有自己的资源。一般地说,线程自己不能拥有资源(也有一点必不可少的资源),但它可以访问其隶属进程的资源,亦即一个进程的代码段、数据段以及系统资源(如已打开的文件、I/O设备等),可供同一个进程的其他所有线程共享。


    (4)独立性:
            在同一进程中的不同线程之间的独立性要比不同进程之间的独立性低得多。这是因为

    为防止进程之间彼此干扰和破坏,每个进程都拥有一个独立的地址空间和其它资源,除了共享全局变量外,不允许其它进程的访问。但是同一进程中的不同线程往往是为了提高并发性以及进行相互之间的合作而创建的,它们共享进程的内存地址空间和资源,如每个线程都可以访问它们所属进程地址空间中的所有地址,如一个线程的堆栈可以被其它线程读、写,甚至完全清除。

     

    (5)系统开销:

           由于在创建或撤销进程时,系统都要为之分配或回收资源,如内存空间、I/O设备等。因此,操作系统为此所付出的开销将显著地大于在创建或撤消线程时的开销。类似的,在进程切换时,涉及到整个当前进程CPU环境的保存环境的设置以及新被调度运行的CPU环境的设置,而线程切换只需保存和设置少量的寄存器的内容,并不涉及存储器管理方面的操作,可见,进程切换的开销也远大于线程切换的开销。此外,由于同一进程中的多个线程具有相同的地址空间,致使他们之间的同步和通信的实现也变得比较容易。在有的系统中,现成的切换、同步、和通信都无需操作系统内核的干预。

     

    (6)支持多处理机系统:
           在多处理机系统中,对于传统的进程,即单线程进程,不管有多少处理机,该进程只能运行在一个处理机上。但对于多线程进程,就可以将一个进程中的多个线程分配到多个处理机上,使它们并行执行,这无疑将加速进程的完成。因此,现代处理机OS都无一例外地引入了多线程。

    以上原文链接:https://blog.csdn.net/u010365819/article/details/76040091?locationNum=5&fps=1

    下面举个Windows下例子:

    我只运行了一个浏览器,为什么有多个进程呢?

    因为现在的浏览器为了增强稳定性,使用户有个好的上网体验,每打开一个网页就做为独立进程,当浏览器浏览的某个网页由于某种问题不得不退出的时候,不会影响到你同时打开的其它网页,因为其它网页在其它进程内存空间里,不在同空间。否则,如果不管打开多少网页,只有一个进程,那所有进程都在同一内存空间,那一个网页崩溃的时候,会导致你同时打开的所有网页关掉,那用户体验会非常糟糕的。

    展开全文
  • methods watchcompute的区别和联系

    千次阅读 2019-04-17 16:14:43
    1、computed\watch:watchcomputed都是以Vue的依赖追踪机制为基础的,它们都试图处理这样一件事情:当某一个数据(称它为依赖数据)发生变化的时候,所有依赖这个数据的“相关”数据“自动”发生变化,也就是自动...
    一、作用机制上
    • 1、computed\watch:watchcomputed都是以Vue的依赖追踪机制为基础的,它们都试图处理这样一件事情:当某一个数据(称它为依赖数据)发生变化的时候,所有依赖这个数据的“相关”数据“自动”发生变化,也就是自动调用相关的函数去实现数据的变动。
    • 2、methods:methods里面是用来定义函数的,很显然,它需要手动调用才能执行。而不像watch和computed那样,“自动执行”预先定义的函数。

    【总结】:·methods·里面定义的函数,是需要主动调用的,而和watchcomputed相关的函数,会自动调用,完成我们希望完成的作用。

    二、从性质上看
    • 1、methods里面定义的是函数,你显然需要像"fuc()"这样去调用它(假设函数为fuc)。
    • 2、computed是计算属性,事实上和和data对象里的数据属性是同一类的(使用上)
    • 例如:
    computed:{
       fullName: function () { return  this.firstName + lastName }
    } 
    
    • 你在取用的时候,用this.fullName去取用,就和取data一样(不要当成函数调用!!)
    • 3、watch:类似于监听机制+事件机制
    • 例如:
    watch: {
       firstName: function (val) {  this.fullName = val + this.lastName }
    }
    
    • firstName的改变是这个特殊“事件”被触发的条件,而firstName对应的函数就相当于监听到事件发生后执行的方法。
    三、watch和computed的对比
    • 1、watch擅长处理的场景:一个数据影响多个数据
    • 2、computed擅长处理的场景:一个数据受多个数据影响
    • 1.1 watch擅长处理的场景:一个数据影响多个数据
      blockchain

    +例如: 在《海贼王》里面,主角团队的名称叫做:“草帽海贼团”
    所以我们把船员依次称为:
    草帽海贼团索隆,草帽海贼团娜美,以此类推。。。
    我们希望:当船团名称发生变更的时候,这艘船上所有船员的名字一起变更!!
    例如:
    有一天,船长路飞为了加强团队建设,弘扬海贼文化,决定“草帽海贼团”改名为“橡胶海贼团”(路飞是橡胶恶魔果实能力者)

    var vm = new Vue({
      el: '#app',
      /*
       data选项中的数据:
       1.haiZeiTuan_Name --> 海贼团名称
       2.船员的名称 = 海贼团名称(草帽海贼团) + 船员名称(例如索隆)
     
       这些数据里存在这种关系:
       (多个)船员名称数据 --> 依赖于 --> (1个)海贼团名称数据
        一个数据变化 --->  多个数据全部变化
      */
      data: {
        haiZeiTuan_Name: '草帽海贼团',
        suoLong: '草帽海贼团索隆',
        naMei: '草帽海贼团娜美',
        xiangJiShi: '草帽海贼团香吉士'
      },
      /*
       在watch中,一旦haiZeiTuan_Name(海贼团名称)发生改变
       data选项中的船员名称全部会自动改变 (suoLong,naMei,xiangJiShi)
       并把它们打印出来
      */
      watch: {
        haiZeiTuan_Name: function (newName) {
          this.suoLong = newName + '索隆'
          this.naMei = newName + '娜美'
          this.xiangJiShi = newName + '香吉士'
          console.log(this.suoLong)
          console.log(this.naMei)
          console.log(this.xiangJiShi)
        }
      }
    })
     
    // 更改watch选项中监控的主数据
    vm.haiZeiTuan_Name = '橡胶海贼团'
    

    结果:blockchain

    2.1、computed擅长处理的场景:一个数据受多个数据影响
    blockchain
    我们再从一个场景说起:

    • 路飞的全名叫做:蒙奇-D-路飞,他想成为海贼王,但路飞的爷爷卡普(海军英雄)因此感到非常恼怒,于是把“路飞”改成了叫“海军王”,希望他能改变志向
    var vm = new Vue({
      el: '#app',
      /*
       data选项中的数据:firstName,secName,thirdName
       computed监控的数据:lufei_Name
       两者关系: lufei_Name = firstName + secName + thirdName
       所以等式右边三个数据任一改变,都会直接修改 lufei_Name
      */
      data: {
        // 路飞的全名:蒙奇·D·路飞
        firstName: '蒙奇',
        secName: 'D',
        thirdName: '路飞'
      },
      computed: {
        luFei_Name: function () {
          return this.firstName + this.secName + this.thirdName
        }
      }
    })
     
    // 将“路飞”改为“海军王”
    vm.thirdName = '海军王'
    // 打印路飞的全名
    console.log(vm.luFei_Name)
    

    结果:
    blockchain

    四、methods不处理数据逻辑关系,只提供可调用的函数
    • 相比于watch/computed,methods不处理数据逻辑关系,只提供可调用的函数
    new Vue({
      el: '#app',
      template: '<div id="app"><p>{{ say() }}</p></div>',
      methods: {
        say: function () {
          return '我要成为海贼王'
        }
      }
    })
    

    结果:
    blockchain

    五、从功能的互补上看待methods,watch和computed的关系
    • 在很多时候,computed是用来处理你使用watch和methods的时候无法处理,或者是处理起来并不太恰当的情况的
    • 利用computed处理methods存在的重复计算情况
    • 1.methods里面的函数就是一群“耿直Boy”,如果有其他父函数调用它,它会每一次都“乖乖”地执行并返回结果,即使这些结果很可能是相同的,是不需要的
    • 2.而computed是一个“心机Boy”,它会以Vue提供的依赖追踪系统为基础,只要依赖数据没有发生变化,computed就不会再度进行计算
    new Vue({
      el: '#app',
      // 设置两个button,点击分别调用getMethodsDate,getComputedDate方法
      template: '<div id="app"><button @click="getMethodsDate">methods</button><button @click="getComputedDate">computed</button></div>',
      methods: {
        getMethodsDate: function () {
          alert(new Date())
        },
        // 返回computed选项中设置的计算属性——computedDate
        getComputedDate: function () {
          alert(this.computedDate)
        }
      },
      computed: {
        computedDate: function () {
          return new Date()
        }
      }
    
    
    • 第一次点击methods按钮:
      ![blockchain](blockchain
    • 第二次点击methods按钮:
      blockchain

    注意两次点击methods返回的时间是不同的!!

    • 第一次点击computed按钮:
      blockchain
    • 第二次点击computed按钮:
      blockchain

    注意两次点击computed返回的时间是相同的!!
    1.两次点击methods返回的时间是不同的
    2.注意两次点击computed返回的时间是相同的

    【注意】为什么两次点击computed返回的时间是相同的呢?new Date()不是依赖型数据(不是放在data等对象下的实例数据),所以computed只提供了缓存的值,而没有重新计算
    只有符合:1.存在依赖型数据 2.依赖型数据发生改变这两个条件,computed才会重新计算。
    而methods下的数据,是每次都会进行计算的

    六、利用computed处理watch在特定情况下代码冗余的现象,简化代码
    new Vue({
      el: '#app',
      data: {
        fullName: '彭湖湾',
        firstName: '彭',
        secName: '湖',
        thirdName: '湾'
      },
      // watch中的代码显然是同类型,重复的,它并不简洁,也不优雅
      watch: {
        firstName: function (newValue) {
          this.fullName = newValue + this.secName + this.thirdName
          console.log(this.fullName)
        },
        secName: function (newValue) {
          this.fullName = this.firstName + newValue + this.thirdName
          console.log(this.fullName)
        },
        thirdName: function (newValue) {
          this.fullName = this.firstName + this.secName + newValue
          console.log(this.fullName)
        }
      }
    })
    
    • watch中的代码显然是同类型,重复的,它并不简洁,也不优雅,所以我们可以把它变成这样
    new Vue({
      el: '#app',
      data: {
        fullName: '彭湖湾',
        firstName: '彭',
        secName: '湖',
        thirdName: '湾'
      },
      // 对watch中的代码进行重构,实现同样效果
      computed: function () {
        this.fullName = this.firstName + this.secName + this.thirdName
        console.log(this.fullName)
      }
    })
    
    展开全文
  • MVCMVVM的区别和联系

    千次阅读 2015-05-28 12:29:55
    视图控制器知道 view-model 它的公有属性, 但是 view-model 对视图控制器一无所知. 你早就该对这个设计感觉好多了因为我们的关注点在这儿进行更好地分离. 帮助你理解我们如何把组件组装在一起还有组件对应...
  • java类对象的联系区别

    千次阅读 2017-10-11 17:29:24
    广义地讲,具有共同性质的事物的集合就称为类。 在面向对象程序设计中,类是一个独立的单位,它有一个类名,其内部包括成员变量,用于描述对象的属性;还包括类的成员方法,用于描述对象的行为。在 Java 程 序设计中...
  • 关于 HttpWebRequest.CookieContainer与HttpWebResponse.Cookies的相关性质 MSDN其他的博客上有很多,我就不再多说了,没有了解的自己去看看吧。 现在主要说说他们两个的区别。用过这两中属性的童鞋都发现,在...
  • 详解HTML 标签和属性

    千次阅读 2017-12-04 10:00:33
    属性要在开始标签中指定,用来表示该标签的性质和特性。通常都是以“属性名=”值””的形式来表示,用空格隔开后,还可以指定多个属性。指定多个属性时不用区分顺序 颜色的指定方法 用HTML指定颜色有两种方法 1、...
  • 继承与派生的区别和联系

    万次阅读 2018-11-15 15:40:43
    基类的publicprotected成员:访问属性在派生类中保持不变; 基类的private成员:不可直接访问。 2)访问权限 派生类中的成员函数:可以直接访问基类中的publicprotected成员,但不能直接访问基类的private...
  • CookieSession的区别联系

    万次阅读 2015-02-09 11:13:42
     在HTTP协议的定义中,采用了一种机制来记录客户端服务器端交互的信息,这种机制被称为cookie,cookie规范定义了服务器客户端交互信息的格式、生存期、使用范围、安全性。  在JavaScript中可以通过 document....
  • JS中BOMDOM的区别联系

    万次阅读 2016-11-19 15:56:20
    我们都知道, javascript 有三部分构成,ECMAScript,DOMBOM,根据宿主(浏览器)的不同,具体的表现形式也不尽相同,ie其他的浏览器风格迥异。 1. DOM 是 W3C 的标准; [所有浏览器公共遵守的标准] 2. ...
  • 从作用机制和性质上看待methods,watchcomputed的关系 作用机制上从性质上看 watchcomputed的对比 watch擅长处理的场景:一个数据影响多个数据computed擅长处理的场景:一个数据受多个数据影响 m
  • 下面从几个方面阐述一下题目中四个概念的区别联系: 1、概念 2、生命周期 3、职责 4、执行过程 一、概念: 1、servlet:servlet是一种运行服务器端的Java应用程序,具有独立于平台协议的特性,并且可以...
  • B树的度数 阶数区别联系

    万次阅读 2018-09-24 13:43:24
    最近在复习数据结构的时候看到了B树的两种定义,一种是算法导论中的度数说;另一种是维基百科的阶数说。 在此记录一下: ...B树的具体性质这里就不在阐述了,说一下算法导论中与度数相关的:  每个...
  • 单应矩阵 基本矩阵 本质矩阵的区别联系
  • servlet/filter/listener/interceptor区别联系

    万次阅读 多人点赞 2013-01-29 11:06:42
    由于最近两个月工作比较清闲,个人也比较“上进”,利用工作空余时间,也继续学习了一下,某天突然想起struts2struts1的区别的时候,发现为什么struts1要用servlet,而struts2要用filter呢?一时又发现,servlet...
  • 在基于对象的编程中,经常会出现类、对象、属性、方法和事件的概念,然后这么概念之间是有联系和区别的,弄清楚它们之间的不同是学好编程的第一步,但熟悉它们之后,这样我们更容易去理解基于对象的编程。...
  • 对象的区别

    2014-01-22 16:34:44
    1.类对象的区别 具有相同或相似性质的对象的抽象就是类。因此,对象的抽象是类,类的具体化就是对象,也可以说类的实例是对象。  类具有属性,它是对象的状态的抽象,用数据结构来描述类的属性。  类具有操作...
  • 层次分析法属性决策算法

    千次阅读 2020-09-09 21:05:03
    主要由两部分构成:(1)获取决策信息——一般包括属性权重和属性值(实数、区间数语言),其中属性权重的确定是多属性决策中的一个重要研究内容;(2)通过一定方法对决策信息进行集结并对方案进行排序择优。 ...
  • 第六章的内容属性文法语法制导翻译,在我看来就是在语法分析的基础上,给每个文法符号、文法产生式赋予相应的属性值或是语法含义。比如赋予E-&gt;E1+E2的含义为E.val := E1.val + E2.val。在实际的应用中可以...
  • 实体与属性间的划分原则

    千次阅读 2017-03-14 17:51:29
    为了简化E-R图的处置,现实世界的事物能作为属性对待的,尽量作为属性对待。 两条准则: (1)作为属性,不能再具有需要描述的性质。...(2)属性不能与其他实体具有联系,即E-R图中所表示的联系是实体之间的联系
  • 四个概念详细分析servlet、filter、listener、interceptor的区别联系?  1、servlet:servlet是一种运行服务器端的Java应用程序,具有独立于平台协议的特性,并且
  • propertyattribute的区别

    千次阅读 2014-03-28 15:46:07
    而attribute则是描述对象在编译时或运行时属性的,分为固有型用户自定义型,其中用户自定义型可以利用Reflection在运行期获取。 这两者是有本质区别的。 资料上说二者一个是service的属性,而另一个是...
  • 产品与服务的联系区别

    千次阅读 2013-03-28 15:30:57
    人类从诞生至今经过了原始社会封建社会资本主义社会社会主义社会社会性之虽然有所不同但是贯穿其中维持其发展促进其发展的一个很重要的因素是一样的。那就是维持人类发展的产品与服务。没有产品这一个至关重要的...
  • 原型是一个对象,其他对象可以通过它实现属性继承。 对象又是什么呢? 在javascript中,一个对象就是任何无序键值对的集合,如果它不是一个主数据类型(undefined,null,boolean,number,string),那它就是一个对象...
  • 人类区别于其他物体,植物,动物的最主要区别,作者认为是“智慧”。而智慧的最佳体现是什么? 是计算能力么,应该不是,心算速度快的人我们一般称之为天才。 是反应能力么,也不是,反应快的人我们称之...
  • .c.h文件的区别

    万次阅读 多人点赞 2004-10-24 23:20:00
    一个简单的问题:.c.h文件的区别学了几个月的C语言,反而觉得越来越不懂了。同样是子程序,可以定义在.c文件中,也可以定义在.h文件中,那这两个文件到底在用法上有什么区别呢? 2楼:子程序不要定义在.h中。函数...
  • 频率概率的区别

    千次阅读 2019-07-15 15:48:01
    概率是某一事件所固有的性质.频率是变化的每次试验可能不同,概率是稳定值不变.在一定条件下频率可以近似代替概率. 就比如,抛硬币,正面的次数/总的次数=正面出现的频率,当抛得的次数越来越多的时候,频率就可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,107
精华内容 7,242
关键字:

性质和属性的区别联系