精华内容
下载资源
问答
  • 生活随记 - 2020国庆第五天

    万次阅读 2020-10-07 00:40:43
    2020-10-04 国庆第五天 别了602 昨天忙到很晚,把房子收拾整理干净利索了,预计今天上午可以和买家交房,买卖合同里面有交房的大概事项,如下所示: 1、房屋保修期问题 这个是商品房统一的,小区所有房子基本...

     

    2020-10-04 国庆第五天 别了602

    昨天忙到很晚,把房子收拾整理干净利索了,预计今天上午可以和买家交房,买卖合同里面有交房的大概事项,如下所示:

     

    1、房屋保修期问题

    这个是商品房统一的,小区所有房子基本一样,中介对这个没有标明也不需要验证,中介已经整理清楚了。

    【这个我们不涉及】

     

    2、房屋质量问题

       a)、墙体裂缝及楼板裂缝。

        b)、渗漏。注意查看厨房、卫生间向外的水平渗漏,以及向楼下的渗漏情况,如果漏水到楼下的邻居家?您家的日子一定不好过,还要注意天花板、窗台下面有无水渍。

        c)、上、下水的质量情况往往需要一个考察周期才能看出问题,在现场可以开打水流,看看水压大小,试试排水速度。

    如果在房屋验收的过程中发现问题,一定要在验收交接记录中注明。注意向卖方索要《住宅质量保证书》和《住宅使用说明书》,以便日后需要。

    【这个买房的时候以及调查清楚,昨天下雨天,过来的时候,也顺道检查了一天,这块没有问题】
     

    3、交接钥匙

    要注意接收全部钥匙,包括楼单元门钥匙、进户门钥匙、室内各房间的钥匙、信箱钥匙、水表、电表(若有远程抄表另)的钥匙。

    【这块没有问题】

     

    4、交接水、电、煤气、物业管理等费用

        a)、结清水表账单。在交房时,双方须要进行抄表读数,并按实际的抄表数由业主结清所欠费用。还要注意是否存在逾期未缴费的情况,要卖方提交近期的水费账单。

        b)、结清电表、煤气表帐单,注意事项同上,用智能卡缴费的,一定要接收智能卡。

        c)、办理有线电视过户。

        d)、结清电话,宽带费用。如果需要继续使用原有的电话号码,应当到电信部门办理过户手续,并以交房当日为准结算电话、宽带费用账单。

        e)、结算维修资金。

        f)、办理物业更名及结算物业管理费用。

        g)、迁移户口。备注(这块是交房之后一年内迁出,留了一点点尾款在中介手里)

    【这块物业费用还没有开始收,到时候收取的时候,我们再支付3/4。水电煤写了个数字等抄煤气表的时候一起结算,其它的都没有】

     

    5、结清二手房尾款

       我们的尾款就是户口迁移留的尾款,交房事项里面不涉及这个。

    【这块没有问题】

     

    6、交房情况:

    顺顺利利交房,还差迁户口留尾款这一项,其它都蛮顺利。^_^,最后我们交房之前,还整理出一个电池炉和两个收纳盒,未来可能用得上的,带回来了,走之前回头望了一眼,在心里默默到了别:“别了602,再见602,往事都已经随风而去,我们也去新的地方开始新的生活,祝新业主万事如意,也祝福我们自己未来平平安安!,我们的交易都是学区房都是为了孩子,希望未来孩子们努力学习,保底也念个正规本科!”。

    到此国庆交房事项基本结束了,剩下的就是现在租住的房子客厅里面有大量的包裹,需要再次归纳放置到房间的衣柜或者角落里面去,虽然经历了下雨等恶劣天气以及中间一些不愉快的沟通交涉,但是结果总归是蛮顺利的。其实最让家人欣慰的是把那个9成新的冰箱搬回来了,这下家里有2个冰箱了,能满足家人愉快的使用了。

    展开全文
  • 乐优商城第五天(Vue.js)

    千次阅读 2018-05-26 21:30:47
    很快,乐优商城来到乐第五天。这一天的学习让我感触很多。首先,膜拜一下Vue的作者尤雨溪,一个中国人,在美国学艺术史的中国人,竟然可以写出这么有灵性的东西,在下是真的佩服,有点无敌啊。而且他还是知乎上的...

        很快,乐优商城来到乐第五天。这一天的学习让我感触很多。首先,膜拜一下Vue的作者尤雨溪,一个中国人,在美国学艺术史的中国人,竟然可以写出这么有灵性的东西,在下是真的佩服,有点无敌啊。而且他还是知乎上的活跃分子,留下了很多牛鼻的回答,有些回答还很有深意,令人深思。一个大神原来也可以跟普通人一样,玩知乎,泡论坛,突然让我产生了一种亲近感,让我感觉我选择这行一点没错,计算机这行是年轻人的天下,通过我们的努力是可以改变很多的,不像那种传统行业,很少有人会活跃在论坛等各种地方,讨论和创新也不会向计算机这行这么热烈。我觉得,我最正确的决定就是果断选择了计算机,我可以在开源社区跟陌生人讨论技术,我还可以关注到行业的大神他们的动态,感受到大神们把各行各业的设计思想灵活运用的巧妙,世界各行各业都是相通的,热爱生活,善于发现,我们也可以把其他地方,其他行业,生活中能工巧匠发明的,发现的巧妙的事物引入进来,这是这个行业给我的希望,是其他行业所不能给我的。

        有时候,我会惊叹于Aop,Ioc,这些巧妙的思想是如何被大神们想出来,运用到java中的,我也会想通用mapper,分页助手,这些好用的东西,省时省事的工具,大神们又是怎么能够想出来的,还有想今天vue双向绑定这种思想,不再需要繁琐的dom操作,这些人真的都是能工巧匠!!

        好了,切入正题,今天的正题是vue,之前说了好多废话额。。。。。

        首先是vue的安装

    idea中安装vue的支持


    谷歌中安装vue的插件


    windows安装node.js环境

    下载地址:https://nodejs.org/en/download/

    安装的时候全部点击下一步即可

    在控制台输入node -v,可以查看版本,安装完成以后要重启

    npm -v可以查看仓库

    我们要更改为国内的仓库

    安装镜像切换工具 npm install nrm -g

    查看仓库列表nrm ls

    更换仓库nrm use taobao

    更换完成后测试速度 nrm test npm

    安装完成node.js,需要用到npm指令安装vue到项目中

    首先在项目目录下打开控制台

    先输入命令:npm int -y进行初始化

    安装vue,输入命令:npm install vue --save.


    一切准备就绪,正式进入vue。

    Vue

    vue本身是一个对象,我们使用的时候,首先要先创建对象


    var app = new Vue({
        el: "#app",
        data: {
            name: "C",
            num: 1,
            hello: "<h2>你是text还是html</h2>",
            lanauge: [],
            message:"",
            users:[
                {name:'柳岩', gender:'', age: 21},
                {name:'虎哥', gender:'', age: 30},
                {name:'范冰冰', gender:'', age: 24},
                {name:'刘亦菲', gender:'', age: 18},
                {name:'古力娜扎', gender:'', age: 25}
            ],
            user:{
                "name":"张三",
                "age":18,
                "sex":""
            },
            show:true,
            type:"A",
            isActive:["red","green"],
            birthday:1429032123201
        },
        methods: {
            add() {
                this.num++;
            },
            print(msg){
                console.log(msg)
            }
        },
        computed:{
            birth(){// 计算属性本质是一个方法,但是必须返回结果
                const d = new Date(this.birthday);
                return d.getFullYear() + "-" + d.getMonth() + "-" + d.getDay();
            }
        },
        watch:{
            message(newVal, oldVal){
                console.log(newVal, oldVal);
            }
        }
    
    });

    我们发现对象的属性可以有很多,我们常用的是

    el:规定要操作的数据的范围

    data:数据

    vue是一种mvvm框架,model到view,view到model双向绑定的模式,这跟以前是很大的区别。

    一。数据的处理

    数据时通过双向绑定的方式处理的,页面中的数据变化,也会影响vue对象中的数据,vue对象中发的数据变化,也会影响页面中的数据。

    二。事件的处理

    我们要操作双向绑定的数据,要遵从vue中的语法。时间的绑定用的是v-on:事件名=“表达式”,这种方式,

    举个栗子:

    <button v-on:click="num++">点我</button>

    钩子函数,vue的生命周期主要分为:对象创建,数据挂载,数据更新,对象销毁

    • beforeCreate

              在实例初始化之后,数据观测(data observer) 和 event/watcher 事件配置之前被调用。


    • created

             实例已经创建完成之后被调用。在这一步,实例已完成以下的配置:数据观测(data observer),属性和方法的运算, watch/event 事件回调。然而,挂载阶段还没开始,$el 属性目前不可见。


    • beforeMount

              在挂载开始之前被调用:相关的 render 函数首次被调用。


    • mounted

              el 被新创建的 vm.$el 替换,并挂载到实例上去之后调用该钩子。如果 root 实例挂载了一个文档内元素,当 mounted 被调用时 vm.$el 也在文档内。


    • beforeUpdate

               数据更新时调用,发生在虚拟 DOM 重新渲染和打补丁之前。 你可以在这个钩子中进一步地更改状态,这不会触发附加的重渲染过程。


    • updated

              由于数据更改导致的虚拟 DOM 重新渲染和打补丁,在这之后会调用该钩子。

              当这个钩子被调用时,组件 DOM 已经更新,所以你现在可以执行依赖于 DOM 的操作。然而在大多数情况下,你应该避免在此期间更改状态,因为这可能会导致更新无限循环。

              该钩子在服务器端渲染期间不被调用。


    • beforeDestroy

               实例销毁之前调用。在这一步,实例仍然完全可用。


    • destroyed

               Vue 实例销毁后调用。调用后,Vue 实例指示的所有东西都会解绑定,所有的事件监听器会被移除,所有的子实例也会被销毁。 该钩子在服务器端渲染期间不被调用。

        使用方式:



    如果在vue对象中使用this,这里的this就代表的是vue对象。

    总结:以上是vue的基本入门,前端无非就是数据的渲染,时间的监听,我们数据渲染用的是双向绑定,脱离dom操作

    我们的时间监听用的是v-on:,最后是,vue的使用是通过创建对象的方式。


    下面,我们来具体玩一下vue

    vue中有很多的指令,这个是他能够响应式操作的精髓

    首先,最重要的是我们的插值表达式 {{}}

    他能够将我们data中的数据插入到dom中,这个是基本操作。

    但是,这中插值操作会产生问题,插值闪烁的问题,vue为我们提供了解决这个问题的方式

    v-text: v-html:

    用v-text或者v-html的方式插入,这两种方式具体的区别可以根据字面意思理解。

    但是,上面的两种方式是单向绑定。


    v-model

    html中还有一个很重要的操作,那就是表单的操作

    v-model可以使用的标签:


    • input

    • select

    • textarea

    • checkbox

    • radio

    • components(Vue中的自定义组件)

    除了最后一项,基本上都是表单中的标签


    v-on:事件的绑定

    事件的修饰符:

    • .stop :阻止事件冒泡

    • .prevent:阻止默认事件发生

    • .capture:使用事件捕获模式

    • .self:只有元素自身触发事件才执行。(冒泡或捕获的都不执行)

    • .once:只执行一次

    还有键盘修饰符,组合修饰符,不是很常用,这里就不写了

    v-for遍历数组:

    语法:v-for="item in items"

    数组中一般都是有角标的,我们希望拿到数组的角标

    v-for="(item,index) in items"

    v-for不仅可以遍历数组,也可以遍历对象

    v-for="(value,key,index) in object"

    v-for还有一个很重要的辅助指令

    :key=index

    这个指令相当于缓存的意思,可以提高效率。如果数据已经被渲染,后来发生改动,我们不会重新遍历这个数组,而会采用就对服用的操作。而我们这个:key就可以起到就地复用的作用。


    v-if和v-show

    这两个指令都是起到判断的作用,后面都接的是boolean表达式,他们的区别在于v-if会将false调的数据不拿到页面上,而v-else会将false掉的数据拿到页面上,只不过用一个display:none的方式进行处理。


    当然还有v-else,使用方式

    <div v-if="Math.random() > 0.5">
      Now you see me
    </div>
    <div v-else>
      Now you don't
    </div>

    还有多重else,使用方式

    <div v-if="type === 'A'">
      A
    </div>
    <div v-else-if="type === 'B'">
      B
    </div>
    <div v-else-if="type === 'C'">
      C
    </div>
    <div v-else>
      Not A/B/C

    </div>


    我们知道,属性上是不能够使用插值表达式的,但是很多时候,我们又会有这样的需求,怎么解?

    vue给我们提供了一个指令,v-bind,可以把vue对象中的属性,插入到html的属性中。

    例如:v-bind:class,可以简写成:class

    以上基本上是vue中的指令


    另外,我们页面中有时候会涉及到复杂的计算,我们如果直接在页面中计算,会显得太复杂,于是,我们vue对象给我们提供了一个computed属性来进行计算,他只需要给我们一个返回值即可。

    var vm = new Vue({
        el:"#app",
        data:{
            birthday:1429032123201 // 毫秒值
        },
        computed:{
            birth(){// 计算属性本质是一个方法,但是必须返回结果
                const d = new Date(this.birthday);
                return d.getFullYear() + "-" + d.getMonth() + "-" + d.getDay();
            }
        }

    })

    我们在页面中用的时候,直接一个插值表达式即可

    <div id="app">
           <h1>您的生日是:{{birth}} </h1>
        </div>

    对于页面中的值,有的时候,我们需要监控,vue也给我们提供了一个监视的属性

    watch:{
                message(newVal, oldVal){
                    console.log(newVal, oldVal);
                }
            }

    他会监视我们值的变化。



    乐优商城,乐优商城,乐优商城,乐优商城,乐优商城,乐优商城,乐优商城,乐优商城,乐优商城,乐优商城,乐优商城

    展开全文
  • ,有多少线程就有多少个这三个模块,声明周期跟所属线程的声明周期一致。以程序计数器为例,因为多线程是通过线程轮流切换和分配执行时间来实现,所以当线程切回到正确执行位置,每个线程都有独立的程序技术器,各个...

    另外,小编也有根据以下总结内容,录制了对JVM讲解视频。里面有个用visio画的JVM内部结构图,每部分的作用都有详细讲解,希望能有帮助。网址:https://edu.csdn.net/lecturer/board/10494

     

    1.java自动管理堆(heap)和(栈),程序员不能直接的设置堆和栈。

    3.操作系统的堆和栈:

    堆(操作系统):一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收,分配方式类似于链表。

    栈(操作系统):由操作系统自动分配释放,存放函数的参数值,局部变量值等。操作方式与数据结构中的栈相类似。

    2.为什么jvm的内存是分布在操作系统的堆中呢??因为操作系统的栈是操作系统管理的,它随时会被回收,所以如果jvm放在栈中,那java的一个null对象就很难确定会被谁回收了,那gc的存在就一点意义都莫有了,而要对栈做到自动释放也是jvm需要考虑的,所以放在堆中就最合适不过了。

    4,

    上图表明:jvm虚拟机位于操作系统的堆中,并且,程序员写好的类加载到虚拟机执行的过程是:当一个classLoder启动的时候,classLoader的生存地点在jvm中的堆,然后它会去主机硬盘上将A.class装载到jvm的方法区,方法区中的这个字节文件会被虚拟机拿来new A字节码(),然后在堆内存生成了一个A字节码的对象,然后A字节码这个内存文件有两个引用一个指向A的class对象,一个指向加载自己的classLoader

    5,java虚拟机的生命周期:声明周期起点是当一个java应用main函数启动时虚拟机也同时被启动,而只有当在虚拟机实例中的所有非守护进程都结束时,java虚拟机实例才结束生命。

    6,java虚拟机与main方法的关系:main函数就是一个java应用的入口,main函数被执行时,java虚拟机就启动了。启动了几个main函数就启动了几个java应用,同时也启动了几个java的虚拟机。

    7,java的虚拟机种有两种线程,一种叫叫守护线程,一种叫非守护线程(也叫普通线程),main函数就是个非守护线程,虚拟机的gc就是一个守护线程。java的虚拟机中,只要有任何非守护线程还没有结束,java虚拟机的实例都不会退出,所以即使main函数这个非守护线程退出,但是由于在main函数中启动的匿名线程也是非守护线程,它还没有结束,所以jvm没办法退出

    8,虚拟机的gc(垃圾回收机制)就是一个典型的守护线程。

    9,实例理解“当所有的非守护线程全部解说,jvm声明周期才结束”:

    public class MianAndThread{
        public static void main( String args[]){
            new Thread(new Runnable(){
                        @override
                        public void run(){
                            Thread.currendThread.sleep(5000s);
                            System.out.println("睡了5s后打印,这是出main之外的非守护线程,这个推出后这个引用结束,jvm声明周期结束。任务管理的java/javaw.exe进程结束"
                        }
            }
            System.out.println("mian线程直接打印,mian线程结束,电脑任务管理器的java/javaw.exe进程并没有结束。")
        }   
    } 

    10,GC垃圾回收机制不是创建的变量为空是就被立刻回收,而是超出变量的作用域后就被自动回收。

    11,程序在jvm原先的流程:

    首先,当一个程序启动之前,它的class会被类装载器装入方法区(不好听,其实这个区我喜欢叫做Permanent区),执行引擎读取方法区的字节码自适应解析,边解析就边运行(其中一种方式),然后pc寄存器指向了main函数所在位置,虚拟机开始为main函数在java栈中预留一个栈帧(每个方法都对应一个栈帧),然后开始跑main函数,main函数里的代码被执行引擎映射成本地操作系统里相应的实现,然后调用本地方法接口,本地方法运行的时候,操纵系统会为本地方法分配本地方法栈,用来储存一些临时变量,然后运行本地方法,调用操作系统APIi等等。 

    12,根据Java虚拟机规范的规定,如果方法区的内存空间不能满足内存分配需要时,将抛出OutOfMemoryError异常。

    13,jvm的结构图:

    方便理解可把上图分为“功能区”和"数据区”(好好理解功能和数据的含义(一动一静)):参考下面13.1,功能区:垃圾回收系统、类加载器、执行引擎;数据区:也就是整个运行时数据区;

    13.1 jvm内部执行运行流程图:

    这里写图片描述

     

    14,jvm结构图各模块的生命周期总结:

    对13中的结构图,做一下统计,启动一个jvm虚拟机程序就是启动了一个进程。启动的同时就在操作系统的堆内存中开辟一块jvm内存区,对于13图中各个小模块的声明周期:

    虚拟机栈、本地方法栈、程序计数器这三个模块是线程私有的,有多少线程就有多少个这三个模块,声明周期跟所属线程的声明周期一致。以程序计数器为例,因为多线程是通过线程轮流切换和分配执行时间来实现,所以当线程切回到正确执行位置,每个线程都有独立的程序技术器,各个线程之间的计数器互不影响,独立存储。

    其余是跟JVM虚拟机的生命周期一致。

    15,13图中,程序计数器模块是JVM内存区域唯一不会报outofMemoryError情况的区域。

    16,结合13图,我们总结出JVM内存包含两个子系统两个组件,两个子系统是:Classloader子系统和Executionengine(执行引擎)子系统;两个组件分别是:Runtimedataarea(运行时数据区域)组件和Nativeinterface(本地库接口)组件。

    从图中可以看出运行时数据区域包含5部分:方法区,堆,虚拟机栈,本地方法栈,程序计数器

    17,什么是本地库接口和本地方法库:(1)本地方法库接口:即操作系统所使用的编程语言的方法集,是归属于操作系统的。(2)本地方法库保存在动态链接库中,即.dll(windows系统)文件中,格式是各个平台专有的。(3)个人感觉上图的本地库接口有点多余,以下面代码为例:

    计算两个int的和(传入int参数并返回int类型)

    class Calc
    {
            static{
                    System.loadLibrary("Calc");
            }
    
            public static native int add(int a, int b);
    
            public static void main(String[] args)
            {
                    System.out.println(add(11,23));
            }
    }

    对应的C代码:

    #include <stdio.h>
    #include "Calc.h"
    
    /* jint 对应着java 的int类型  */
    JNIEXPORT jint JNICALL Java_Calc_add(JNIEnv *env, jclass jc, jint a, jint b)
    {
            jint ret = a + b;
            return ret;
    }

    在java代码中会通过System.loadLibrary("")加载c语言库(本地方法库)直接与操作系统平台交互。

    18,双亲委派机制:JVM在加载类时默认采用的是双亲委派机制。通俗的讲,就是某个特定的类加载器在接到加载类的请求时,首先将加载任务委托给父类加载器,依次递归,如果父类加载器可以完成类加载任务,就成功返回;只有父类加载器无法完成此加载任务时,才自己去加载。

    见下图:

     例如:当jvm要加载Test.class的时候,

      (1)首先会到自定义加载器中查找(其实是看运行时数据区的方法区有没有加载),看是否已经加载过,如果已经加载过,则返回字节码。

      (2)如果自定义加载器没有加载过,则询问上一层加载器(即AppClassLoader)是否已经加载过Test.class。

      (3)如果没有加载过,则询问上一层加载器(ExtClassLoader)是否已经加载过。

      (4)如果没有加载过,则继续询问上一层加载(BoopStrap ClassLoader)是否已经加载过。

      (5)如果BoopStrap ClassLoader依然没有加载过,则到自己指定类加载路径下("sun.boot.class.path")查看是否有Test.class字节码,有则返回,没有通

    知下一层加载器ExtClassLoader到自己指定的类加载路径下(java.ext.dirs)查看。

      (6)依次类推,最后到自定义类加载器指定的路径还没有找到Test.class字节码,则抛出异常ClassNotFoundException。

    代码如下:

    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            synchronized (getClassLoadingLock(name)) {
                // 首先,检查是否已经加载过
                Class<?> c = findLoadedClass(name);
                if (c == null) {
                    long t0 = System.nanoTime();
                    try {
                        if (parent != null) {
                            //父加载器不为空,调用父加载器的loadClass
                            c = parent.loadClass(name, false);
                        } else {
                            //父加载器为空则,调用Bootstrap Classloader
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) {
                        // ClassNotFoundException thrown if class not found
                        // from the non-null parent class loader
                    }
    
                    if (c == null) {
                        // If still not found, then invoke findClass in order
                        // to find the class.
                        long t1 = System.nanoTime();
                        //父加载器没有找到,则调用findclass
                        c = findClass(name);
    
                        // this is the defining class loader; record the stats
                        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                        sun.misc.PerfCounter.getFindClasses().increment();
                    }
                }
                if (resolve) {
                    //调用resolveClass()
                    resolveClass(c);
                }
                return c;
            }
        }

    为什么要使用这种加载方式呢?这里要注意几点,1,类加载器代码本身也是java类,因此类加载器本身也是要被加载的,因此显然必须有第一个类加载器不是Java类,这就是bootStrap,是使用c++写的其他这是java了。2,虽说bootStrap、extclassLoader、appclassloader三个是父子类加载器关系,但是并没有使用继承,而是使用了组合关系。3,优点,具备了一种带优先级的层次关系,越是基础的类,越是被上层的类加载器进行加载,可以比较笼统的说像jdk自带的几个jar包肯定是位于最顶级的,再就是我们引用的包,最后是我们自己写的,保证了java程序的稳定性。

    19,jdk,jre,JVM的关系:JDK(Java Development Kit) 是 Java 语言的软件开发工具包(SDK)。在JDK的安装目录下有一个jre目录,里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm,lib中则是jvm工作所需要的类库,而jvm和 lib合起来就称为jre。

    jdk,jre,JVM的关系图:

    20,JVM运行简易过程:

    上图左半部分其实不是在JVM中,程序员在eclipse上写的是.java文件,经过编译成.class文件(比如maven工程需要maven install,打成jar报,jar包里面都是.calss文件);这些步骤都是在eclipse上进行的。然后类加载器(classloader)一直到解释器是属于JVM的

    21,解释13中JVM结构图各模块的内容:

    程序计数器(Program Counter Register):也叫PC寄存器,是一块较小的内存空间,它可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里,字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令、分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。,(1),区别于计算机硬件的pc寄存器,两者不略有不同。计算机用pc寄存器来存放“伪指令”或地址,而相对于虚拟机,pc寄存器它表现为一块内存(一个字长,虚拟机要求字长最小为32位),虚拟机的pc寄存器的功能也是存放伪指令,更确切的说存放的是将要执行指令的地址。(2)当虚拟机正在执行的方法是一个本地(native)方法的时候,jvm的pc寄存器存储的值是undefined。(3)程序计数器是线程私有的,它的生命周期与线程相同,每个线程都有一个。(4)此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

    Java虚拟机栈(Java Virtual Machine Stack):(1)线程私有的,它的生命周期与线程相同,每个线程都有一个。(2)每个线程创建的同时会创建一个JVM栈,JVM栈中每个栈帧存放的为当前线程中局部基本类型的变量(java中定义的八种基本类型:boolean、char、byte、short、int、long、float、double;和reference (32 位以内的数据类型,具体根据JVM位数(64为还是32位)有关,因为一个solt(槽)占用32位的内存空间 )、部分的返回结果,非基本类型的对象在JVM栈上仅存放一个指向堆上的地址;(3)每一个方法从被调用直至执行完成的过程就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。(5)栈运行原理:栈中的数据都是以栈帧(Stack Frame)的格式存在,栈帧是一个内存区块,是一个数据集,是一个有关方法和运行期数据的数据集,当一个方法A被调用时就产生了一个栈帧F1,并被压入到栈中,A方法又调用了B方法,于是产生栈帧F2也被压入栈,B方法又调用了C方法,于是产生栈帧F3也被压入栈…… 依次执行完毕后,先弹出后进......F3栈帧,再弹出F2栈帧,再弹出F1栈帧。(6)JAVA虚拟机栈的最小单位可以理解为一个个栈帧,一个方法对应一个栈帧,一个栈帧可以执行很多指令,如下图:

    (7)对上图中的动态链接解释下,比如当出现main方法需要调用method1()方法的时候,操作指令就会触动这个动态链接就会找打方法区中对于的method1(),然后把method1()方法压入虚拟机栈中,执行method1栈帧的指令;此外如果指令表示的代码是个常量,这也是个动态链接,也会到方法区中的运行时常量池找到类加载时就专门存放变量的运行时常量池的数据。

    本地方法栈(Native Method Stack):(1)先解释什么是本地方法:jvm中的本地方法是指方法的修饰符是带有native的但是方法体不是用java代码写的一类方法,这类方法存在的意义当然是填补java代码不方便实现的缺陷而提出的。案例介绍将在 下面22知识点仔细介绍。(2)作用同java虚拟机栈类似,区别是:虚拟机栈为虚拟机执行Java方法服务,而本地方法栈则是为虚拟机使用到的Native方法服务。(3)是线程私有的,它的生命周期与线程相同,每个线程都有一个。

    Java 堆(Java Heap):(1)是Java虚拟机所管理的内存中最大的一块。(2)不同于上面3个,堆是jvm所有线程共享的。(3)在虚拟机启动的时候创建。(4)唯一目的就是存放对象实例,几乎所有的对象实例以及数组都要在这里分配内存。(5)

    Java堆是垃圾收集器管理的主要区域。(6)因此很多时候java堆也被称为“GC堆”(Garbage Collected Heap)。从内存回收的角度来看,由于现在收集器基本都采用分代收集算法,所以Java堆还可以细分为:新生代和老年代;新生代又可以分为:Eden 空间、From Survivor空间、To Survivor空间。(23知识点详细介绍)(7)java堆是计算机物理存储上不连续的、逻辑上是连续的,也是大小可调节的(通过-Xms和-Xmx控制)。(8)如果在堆中没有内存完成实例的分配,并且堆也无法再扩展时,将会抛出OutOfMemoryError异常。

    方法区(Method Area):(1)在虚拟机启动的时候创建。(2)所有jvm线程共享。(3)除了和堆一样不需要不连续的内存空间和可以固定大小或者可扩展外,还可以选择不实现垃圾收集。(5)用于存放已被虚拟机加载的类信息、常量、静态变量、以及编译后的方法实现的二进制形式的机器指令集等数据。(4)被装载的class的信息存储在Methodarea的内存中。当虚拟机装载某个类型时,它使用类装载器定位相应的class文件,然后读入这个class文件内容并把它传输到虚拟机中。(6)运行时常量池(Runtime Constant Pool)是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项信息是常量池(Constant Pool Table),用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池中存放。

    方法区补充:指令集是个非常重要概念,因为程序员写的代码其实在jvm虚拟机中是被转成了一条条指令集执行的,看下图

    首先看看上面各部位位于13图中的那些位置:左侧的foo代码是指令集,可见就是在方法区,程序计数器就不用说了,局部变量区位于虚拟机栈中,右侧最下方的求值栈(也就是操作数栈)我们从动图中明显可以看出存在栈顶这个关键词因此也是位于java虚拟机栈的。

    另外,图中,指令是Java代码经过javac编译后得到的JVM指令,PC寄存器指向下一条该执行的指令地址,局部变量区存储函数运行中产生的局部变量,栈存储计算的中间结果和最后结果。

    上图的执行的源代码是:

    public class Demo {
    
        public static void foo() {
    
           int a = 1;
    
           int b = 2;
    
           int c = (a + b) * 5;
    
        }
    
    }

    下面简单解释下执行过程,注意:偏移量的数字只是简单代表第几个指令哦,首先常数1入栈,栈顶元素就是1,然后栈顶元素移入局部变量区存储,常数2入栈,栈顶元素变为2,然后栈顶元素移入局部变量区存储;接着1,2依次再次入栈,弹出栈顶两个元素相加后结果入栈,将5入栈,栈顶两个元素弹出并相乘后结果入栈,然后栈顶变为15,最后移入局部变量。执行return命令如果当前线程对应的栈中没有了栈帧,这个Java栈也将会被JVM撤销。

    类加载器子系统(class loader subsystem):(1)根据给定的全限定名类名(如java.lang.Object)来装载class文件的内容到Runtimedataarea中的methodarea(方法区域)。Java程序员可以extends java.lang.ClassLoader类来写自己的Classloader。(2) 对(1)中的加载过程是:当一个classloader启动时,classloader的生存地点在jvm中的堆,然后它去主机硬盘上去装载A.class到jvm的methodarea(方法区),方法区中的这个字节文件会被虚拟机拿来new A字节码,然后在堆内存生成了一个A字节码的对象,然后A自己码这个内存文件有两个引用,一个指向A的class对象,一个指向加载自己的classloader。见下图:

     

    执行引擎(Executionengine子系统):(1)负责执行来自类加载器子系统(class loader subsystem)中被加载类中在方法区包含的指令集,通俗讲就是类加载器子系统把代码逻辑(什么时候该if,什么时候该相加,相减)都以指令的形式加载到了方法区,执行引擎就负责执行这些指令就行了。

    用网上最流行的一张图表示就是:

    (1)程序在JVM主要执行的过程是执行引擎与运行时数据区不断交互的过程,可理解为上面“方法区中的动图” (2)但是执行引擎拿到的方法区中的指令还是人能够看懂的,这里执行引擎的工作就是要把指令转成JVM执行的语言(也可以理解成操作系统的语言),最后操作系统语言再转成计算机机器码。

    (3)

    • 解释器:一条一条地读取,解释并且执行字节码指令。因为它一条一条地解释和执行指令,所以它可以很快地解释字节码,但是执行起来会比较慢。这是解释执行的语言的一个缺点。字节码这种“语言”基本来说是解释执行的。
    • 即时(Just-In-Time)编译器:即时编译器被引入用来弥补解释器的缺点。执行引擎首先按照解释执行的方式来执行,然后在合适的时候,即时编译器把整段字节码编译成本地代码。然后,执行引擎就没有必要再去解释执行方法了,它可以直接通过本地代码去执行它。执行本地代码比一条一条进行解释执行的速度快很多。编译后的代码可以执行的很快,因为本地代码是保存在缓存里的。

    上面也是才能够别处拷来的,是对上图的解释,这里的字节码解释器也就对应20中的解释器。简单理解jit就是当代码中某些方法复用次数比较高的,并超过一个特定的值就成为了“热点代码”。那么这个这些热点代码就会被编译成本地代码(其实可以理解成缓存)加快访问速度。

    22,本地(native)方法讲解:

    (1)本地方法就是带有native标识符修饰的方法;(2)native修饰符修饰的方法并不提供方法体,但因为其实现体是由非java代码在在外部实现的,因此不能与abstract连用;(3)存在的意义:不方便用java语言写的代码,使用更为专业的语言写更合适;甚至有些JVM的实现就是用c编写的,所以只能使用c来写,

    (4)更多的本地方法最好是与jdk的执行引擎的解释器语言一致(执行引擎、解释器:参考21的执行引擎);

    (5)Windows、Linux、UNIX、Dos操作系统的核心代码大部分是使用C和C++编写,底层接口用汇编编写.

    (6)为什么native方法修饰的修饰的方法PC程序计数器为undefined。读懂上面的所有知识点可以就很容易自己理解了。在一开始类加载时,native修饰的方法就被保存在了本地方法栈中,当需要调用native方法时,调用的是一个指向本地方法栈中某方法的地址,然后执行方法直接与操作系统交互,返回运行结果。整个过程并没有经过执行引擎的解释器把字节码解释成操作系统语言,PC计数器也就没有起作用。

    23,GC垃圾回收机制:

    了解堆内存:

    类加载器读取了类文件后,需要把类、方法、常变量放到堆内存中,以方便执行器执行,堆内存分为三部分:

           ① 新生区

           新生区是类的诞生、成长、消亡的区域,一个类在这里产生,应用,最后被垃圾回收器收集,结束生命。新生区又分为两部分:伊甸区(Eden space)和幸存者区(Survivor pace),所有的类都是在伊甸区被new出来的。幸存区有两个:0区(Survivor 0 space)和1区(Survivor 1 space)。当伊甸园的空间用完时,程序又需要创建对象,JVM的垃圾回收器将对伊甸园进行垃圾回收(Minor GC),将伊甸园中的剩余对象移动到幸存0区。若幸存0区也满了,再对该区进行垃圾回收,然后移动到1区。那如果1去也满了呢?再移动到养老区。若养老区也满了,那么这个时候将产生Major GC(FullGCC),进行养老区的内存清理。若养老区执行Full GC 之后发现依然无法进行对象的保存,就会产生OOM异常“OutOfMemoryError”。

         如果出现java.lang.OutOfMemoryError: Java heap space异常,说明Java虚拟机的堆内存不够。原因有二:

        a.Java虚拟机的堆内存设置不够,可以通过参数-Xms、-Xmx来调整。

         b.代码中创建了大量大对象,并且长时间不能被垃圾收集器收集(存在被引用)。

         ② 养老区

             养老区用于保存从新生区筛选出来的 JAVA 对象,一般池对象都在这个区域活跃。

         ③ 永久区

             永久存储区是一个常驻内存区域,用于存放JDK自身所携带的 Class,Interface 的元数据,也就是说它存储的是运行环境必须的类信息,被装载进此区域的数据是不会被垃圾回收器回收掉的,关闭 JVM 才会释放此区域所占用的内存。

         如果出现java.lang.OutOfMemoryError: PermGen space,说明是Java虚拟机对永久代Perm内存设置不够。原因有二:

         a. 程序启动需要加载大量的第三方jar包。例如:在一个Tomcat下部署了太多的应用。

         b. 大量动态反射生成的类不断被加载,最终导致Perm区被占满。

         说明:

         Jdk1.6及之前:常量池分配在永久代 。

         Jdk1.7:有,但已经逐步“去永久代” 。

         Jdk1.8及之后:无(java.lang.OutOfMemoryError: PermGen space,这种错误将不会出现在JDK1.8中)。

    24,21运行时数据区各个模块协作工作的总结较好的图(来自:https://blog.csdn.net/wangtaomtk/article/details/52267634

    首先要执行的代码是:

    先执行main方法:

    当要调用其他方法时:

    25,java代码编译(Java Compiler)过程,也就是由.java文件到.class文件的过程(附上网上很流行的图,个人感觉没必要记,反正我是记不住)

    注:源代码就是.java文件,JVM字节码就是.class文件

    27,是先加载字节码文件还是先执行main方法:先加载字节码文件到方法区,然后在找到main执行程序。

    28,java被编译成了class文件,JVM怎么从硬盘上找到这个文件并装载到JVM里呢?

    是通过java本地接口(JNI),找到class文件后并装载进JVM,然后找到main方法,最后执行。

    29,我们平时所说的八大基本类型的在栈中的存放位置是:运行时数据区--》虚拟机栈--》虚拟机栈的一个栈帧--》栈帧中的局部变量表;局部变量表存放的数据除了八大基本类型外,还可以存放一个局部变量表的容量的最小单位变量槽(slot)的大小,通常表示为reference;所以是可以放字符串类型的,但是要以 String a="aa";的形式出现,如果是new Object()那就只能实在哎堆中了,栈里面存的是栈执行堆的地址。

    30,堆内存大小-Xms -Xmx设置相同,因为-Xmx越大tomcat就有更多的内存可以使用,这就意味着JVM调用垃圾回收机制的频率就会减少(垃圾回收机制被调用是jvm内存不够时自动调用的)可以避免每次垃圾回收完成后JVM重新分配内存。

    31,GC具体什么时候执行,这个是由系统来进行决定的,是无法预测的。

    32,方法区也被成为堆内存中的永久代,看下面例子:

    Student s = new Student("小明",18);
    
    s 是指针,存放在栈中。
    
    new Student("小明",18) 是对象 ,存放在堆中。
    
    Student 类的信息存放在方法区。
    
    总结 :
    
    对象的实例保存在堆上,对象的元数据(instantKlass)保存在方法区,对象的引用保存在栈上。

    类加载是会先看方法区有没有已经加载过这个类,因此方法区中的类是唯一的。方法区中的类都是运行时的,都是正在使用的,是不能被GC的,所以可以理解成永久代。

    33,java 内存模型

    读完上面那么多最后一个知识点,理解下多线程的一点知识。我们应该知道了在运行时数据内存区中虚拟机栈、pc寄存器、本地方法栈是每个线程都有的,很明显这些都是独立的不会发生线程不安全的问题,但是我们平时讨论的线程不安全、要加锁等等情况是怎么回事呢?

    其实,发生线程不安全问题的原因在于cpu,看下图,简单理解cpu

    在CPU内部有一组CPU寄存器,也就是CPU的储存器。CPU操作寄存器的速度要比操作计算机主存快的多。在主存和CPU寄存器之间还存在一个CPU缓存,CPU操作CPU缓存的速度快于主存但慢于CPU寄存器。某些CPU可能有多个缓存层(一级缓存和二级缓存)。计算机的主存也称作RAM,所有的CPU都能够访问主存,而且主存比上面提到的缓存和寄存器大很多。
    当一个CPU需要访问主存时,会先读取一部分主存数据到CPU缓存,进而在读取CPU缓存到寄存器。当CPU需要写数据到主存时,同样会先flush寄存器到CPU缓存,然后再在某些节点把缓存数据flush到主存。

    Java内存模型和硬件架构之间的桥接
    正如上面讲到的,Java内存模型和硬件内存架构并不一致。硬件内存架构中并没有区分栈和堆,从硬件上看,不管是栈还是堆,大部分数据都会存到主存中,当然一部分栈和堆的数据也有可能会存到CPU寄存器中,如下图所示,Java内存模型和计算机硬件内存架构是一个交叉关系:

     

    当对象和变量存储到计算机的各个内存区域时,必然会面临一些问题,其中最主要的两个问题是:

    1. 共享对象对各个线程的可见性2. 共享对象的竞争现象

    问题1:

    共享对象的可见性
    当多个线程同时操作同一个共享对象时,如果没有合理的使用volatile和synchronization关键字,一个线程对共享对象的更新有可能导致其它线程不可见。

    想象一下我们的共享对象存储在主存,一个CPU中的线程读取主存数据到CPU缓存,然后对共享对象做了更改,但CPU缓存中的更改后的对象还没有flush到主存,此时线程对共享对象的更改对其它CPU中的线程是不可见的。最终就是每个线程最终都会拷贝共享对象,而且拷贝的对象位于不同的CPU缓存中。

    下图展示了上面描述的过程。左边CPU中运行的线程从主存中拷贝共享对象obj到它的CPU缓存,把对象obj的count变量改为2。但这个变更对运行在右边CPU中的线程不可见,因为这个更改还没有flush到主存中:

     

     

    要解决共享对象可见性这个问题,我们可以使用java volatile关键字。 Java’s volatile keyword. volatile 关键字可以保证变量会直接从主存读取,而对变量的更新也会直接写到主存。volatile原理是基于CPU内存屏障指令实现的。

    问题2:

    竞争现象
    如果多个线程共享一个对象,如果它们同时修改这个共享对象,这就产生了竞争现象。
    如下图所示,线程A和线程B共享一个对象obj。假设线程A从主存读取Obj.count变量到自己的CPU缓存,同时,线程B也读取了Obj.count变量到它的CPU缓存,并且这两个线程都对Obj.count做了加1操作。此时,Obj.count加1操作被执行了两次,不过都在不同的CPU缓存中。

    如果这两个加1操作是串行执行的,那么Obj.count变量便会在原始值上加2,最终主存中的Obj.count的值会是3。然而下图中两个加1操作是并行的,不管是线程A还是线程B先flush计算结果到主存,最终主存中的Obj.count只会增加1次变成2,尽管一共有两次加1操作。

     

    要解决上面的问题我们可以使用java synchronized代码块。synchronized代码块可以保证同一个时刻只能有一个线程进入代码竞争区,synchronized代码块也能保证代码块中所有变量都将会从主存中读,当线程退出代码块时,对所有变量的更新将会flush到主存,不管这些变量是不是volatile类型的。

    volatile和 synchronized区别
    volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取; synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。

    volatile仅能使用在变量级别;synchronized则可以使用在变量、方法、和类级别的
    volatile仅能实现变量的修改可见性,不能保证原子性;而synchronized则可以保证变量的修改可见性和原子性

    volatile不会造成线程的阻塞;synchronized可能会造成线程的阻塞。
    volatile标记的变量不会被编译器优化;synchronized标记的变量可以被编译器优化
    支撑Java内存模型的基础原理

     

    34,方法区与堆的区别

    方法区存放了类的信息,有类的静态变量、final类型变量、field自动信息、方法信息,处理逻辑的指令集,我们仔细想想一个类里面也就这些东西,而堆中存放是对象和数组,咋一看好像方法区跟堆的作用是一样的。其实呢,1,这里就关系到我们平时说的对象是类的实例,是不是有点恍然大悟了?这里的对应关系就是 “方法区--类”  “堆--对象”,以“人”为例就是,堆里面放的是你这个“实实在在的人,有血有肉的”,而方法区中存放的是描述你的文字信息,如“你的名字,身高,体重,还有你的行为,如吃饭,走路等”。2,再者我们从另一个角度理解,就是从前我们得知方法区中的类是唯一的,同步的。但是我们在代码中往往同一个类会new几次,也就是有多个实例,既然有多个实例,那么在堆中就会分配多个实例空间内存。

     

    35,方法区的内容是一次把一个工程的所有类信息都加载进去再去执行还是边加载边执行呢?

    其实单从性能方面也能猜测到是只加载当前使用的类,也就是边加载边执行。例如我们使用tomcat启动一个spring工程,通常启动过程中会加载数据库信息,配置文件中的拦截器信息,service的注解信息,一些验证信息等,其中的类信息就会率先加载到方法区。但如果我们想让程序启动的快一点就会设置懒加载,把一些验证去掉,如一些类信息的加载等真正使用的时候再去加载,这样说明了方法区的内容可以先加载进去,也可以在使用到的时候加载。

     

    36,方法区,栈、堆之间的过程

    类加载器加载的类信息放到方法区,--》执行程序后,方法区的方法压如栈的栈顶--》栈执行压入栈顶的方法--》遇到new对象的情况就在堆中开辟这个类的实例空间。(这里栈是有此对象在堆中的地址的)

    展开全文
  • 全局变量的值在程序的整个生命周期内都是有效的。 全局变量可以被任何函数访问。也就是说,全局变量一旦声明,在整个程序中都是可用的。 在函数或一个代码块内部声明的变量,称为局部变量。它们只能被函数内部或者...

    1、名词解释

    作用域是程序的一个区域,一般来说有三个地方可以定义变量:
    在函数或一个代码块内部声明的变量,称为局部变量。
    在函数参数的定义中声明的变量,称为形式参数。
    在所有函数外部声明的变量,称为全局变量。

    2、全局变量和局部变量

    在所有函数外部定义的变量(通常是在程序的头部),称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。
    全局变量可以被任何函数访问。也就是说,全局变量一旦声明,在整个程序中都是可用的。
    在函数或一个代码块内部声明的变量,称为局部变量。它们只能被函数内部或者代码块内部的语句使用。
    下面的实例使用了全局变量和局部变量:

    #include <iostream>
    using namespace std;
    
    // 全局变量定义
    int g;
    int main()
    {
    	// 局部变量定义并初始化
    	int a=10, b=20;
    
    	g = a + b; //g=30
    	cout << g; //30
    	return 0;
    }
    

    3、局部变量的值会覆盖全局变量的值

    在程序中,局部变量和全局变量的名称可以相同,但是在函数内,局部变量的值会覆盖全局变量的值。下面是一个实例:

    #include <iostream>
    using namespace std;
    
    // 全局变量定义并初始化
    int g = 20;
    int main()
    {
    	// 局部变量定义并初始化
    	int g = 10;
    	cout << g; //10
    	return 0;
    }
    

    4、我们怎么才能在局部变量和全局变量名称相同的情况下调用全局变量呢?

    4.1、可通过函数引用到全局变量

    #include <iostream>
    using namespace std;
    
    //定义并初始化全局变量
    int a = 10;
    int func() {
    	return a;
    }
    int main()
    {
    	//定义并初始化局部变量
    	int a = 20;
    	cout << "全局变量为: " << func() << endl;   // 10
    	cout << "局部变量为: " << a << endl;     // 20
    	return 0;
    }
    

    2、可通过域名(’ : : ')引用到全局变量
    方法一:全局变量和和局部变量同名时,可通过域名在函数中引用到全局变量,不加域名解析则引用局部变量

    #include <iostream>
    using namespace std;
    
    int a = 10;
    int main()
    {
    	int a = 20;
    	cout << "全局变量为: "<<::a << endl;   // 10
    	cout <<"局部变量为: "<< a << endl;     // 20
    	return 0;
    }
    

    5、初始化局部变量和全局变量

    当局部变量被定义时,系统不会对其初始化,您必须自行对其初始化。定义全局变量时,系统会自动初始化为下列值:

    数据类型 初始化默认值
    int 0
    char ’ \0 ’
    float 0
    double 0
    pointer NULL

    正确地初始化变量是一个良好的编程习惯,否则有时候程序可能会产生意想不到的结果。

    当局部变量被定义时,系统不会对其初始化,您必须自行对其初始化。如果我们没有对局部变量进行初始化,那么程序会报错。

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	// 局部变量定义但是不初始化
    	int g;
    	cout << g; 
    	return 0;
    }
    

    报错:
    报错

    #include <iostream>
    using namespace std;
    
    int a ;
    char b;
    float c;
    double d;
    bool e;
    int* f;
    int main()
    {
    	cout <<	"int: " <<a<<endl;
    	cout << "char: "<<b<<"!!!"<<endl; //b='\0' 而'\0'是空格符
    	cout << "float: "<<c<<endl;
    	cout << "double: "<<d<<endl;
    	cout << "bool: "<<e<<endl;
    	cout << "pointer: "<<f<<endl;
    	if (e)
    		cout << "true";
    	else
    	{
    		cout << "false";
    	}
    }
    

    result

    展开全文
  • 如果重复周期是 “只有一次” 或者 “每天”,算法很好写,只要计算 当前时间 与 给定时间 的时间差就可以... 仅仅重复了两天,如果重复天数达到四五天,逻辑感觉有点复杂。 想问问各位大神有没有好的解决算法。
  • 目前比特币总算力6118 PH/s,挖到区块的平均周期207.7秒,挖到区块的预期周期:219.2秒。 A. AMD HD7950 BE显卡矿机  售价2099元,算力0.69G,回本时间999。 B. 阿瓦隆矿机A741矿机   售价6500元,...
  • 本程序思路是以一个人为起点,10为一个周期,进行传染病的传染,当能够传染到其他人时,再以那个人为起点继续传染。依此递归下去。 public class Infection { static int N = 13; static int men = 1; public ...
  • 有了第一对vue的一些基本认识,如果你有了以下的认识,说明你已经入门vue了 1.0Vue.js是数据驱动的,这使得我们并不需要直接操作DOM,不要再有操作dom的思想了,忘掉以前jquery的思想 1.1.在Vue中,已经实现了...
  • 我预计会分个博客介绍vue,第一会是一些vue的入门指令,第二会是vue的生命周期,第三vue的组件,第四就是组件间的传值,第条将webpack和工作中的项目目录 2.什么是vue 3.vue的架构 vue.js是...
  • 王思聪被限制出境的第

    千次阅读 2018-11-06 00:00:00
    2018年11月5日,北京,晴 我知道就算到周一,很多人仍不知道周末王思聪为何在微信朋友圈刷屏,你试图跟上大家的节奏,却苦于对游戏行业所知甚浅。 天天快报式的平实报道朋友圈不...呼喊地的“震惊”式票圈更加显...
  • 弄到这里,使用Navicat设置定时备份数据库的操作就结束了,但是有两个问题,备份文件非常大的时候,比如我的数据库备份一次就是10个G,那这时候我们往往就需要保留五天左右的数据,五天之前的备份数据就直接删除就行...
  • 玩知乎年,我赚了多少钱?

    千次阅读 2020-07-02 11:03:13
    小方是一位知乎老鸟,玩了快年知乎,上个月知乎粉丝终于突破一万了,惊喜得我不知所措呀。 不止一个读者在问我:小方老师现在也是知乎万粉大 V 了,知乎如此多的关注、点赞,加上付费咨询和 Live,一定赚了...
  • 但是只有在使用的时候才可能删除,对内存不友好) 3)定期删除:隔一段时间检查一次(具体算法决定检查多少多少,需要合理设置) 3.1.5淘汰策略 当Redis占用内存超出最大限制 (maxmemory) 时,可采用如下策略 ...
  • 如何计算某一天是星期几

    千次阅读 2014-09-22 15:45:12
    时间创世纪,第七休息,所以人们也就以七为一个周期来安排自己的工作和生  活,而星期日是休息日。从实际的角度来讲,以七为一个周期,长短也比较合适。所  以尽管中国的传统工作周期是十(比如王勃...
  • 简介 1、Bean的5种作用域 (1)singleton:单例模式,Spring IoC容器中只会存在一个共享的Bean实例,无论有多少个Bean引用它,始终指向同一对象Singleton作用域是Spring中的缺省作用域,也可以显示的将Bean定义为...
  • 计算任意一天是星期几的问题

    千次阅读 2012-09-12 17:25:10
    时间创世纪,第七休息,所以人们也就以七为一个周期来安排自己的工作和生  活,而星期日是休息日。从实际的角度来讲,以七为一个周期,长短也比较合适。所  以尽管中国的传统工作周期是十(比如王勃...
  • 人类的记忆周期

    2019-10-13 22:51:49
    第一个记忆周期 5分钟:超短期记忆 第二个记忆周期 30分钟:短期记忆 第三个记忆周期 12小时: 第四个记忆周期 ...第个记忆周期 2 第六个记忆周期 4 第七个记忆周期 7 第八个记忆周期 15 ...
  • 比特币的第轮价格周期将随着今年下半年突破1万美元而正式开启。趋势一旦确立,未来可期。 (四)从投资策略看,在全球最受欢迎的社交新闻站点Reddit上,比特币论坛出现频次最多的两个词是:HODL(Hold On for ...
  • 开发才1,为什么测试需要2

    千次阅读 2019-01-19 13:43:59
    QA常常需要面临的排期问题  下面是通常会面临的项目场景了: ... 于是当QA说出需要的测试周期时,PM/开发人员通常会产生疑惑:改动特别小,其他的都没改,不需要测试,只测试XXX就行了,不需要这么长时间...
  • 一、实现功能 实现了部分RV32I指令集中的部分指令类型,如下...实现了单周期CPU和级流水线。其中,级流水线为顺序读取、顺序放回;跳转指令可以冲刷流水线;没有预测跳转功能;占用资源较多,微架构面积较大。 ...
  • 合肥Android两十面总结

    千次阅读 2016-04-16 18:40:39
    所以在上周在网上了投了几份简历,也通过合肥的Android开发交流群引荐了一些公司,就此在本周四、周五进行了两十面的苦逼旅程。 周四一安排: 第一家:合肥江湖信息科技有限公司 地址:合肥蜀山区合作化...
  • 个记忆周期:26. 第六个记忆周期:47. 第七个记忆周期:78. 第八个记忆周期:15二、背诵方法:1. 初记单词时需要记忆的内容:a) 单词外观、b)单词的中文释义、c)单词的记忆法2. 每个list的具体背诵过程...
  • 类变量的生命周期和类相同,在整个应用程序执行期间都有效。它有如下特点: 为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。 对于该类的所有对象来说,static成员变量只有一份。被该...
  • [葛勤民]怎样计算任一天是星期几

    千次阅读 2006-10-06 00:46:00
    据说因为《圣经·创世纪》中规定上帝用了六时间创世纪,第七休息,所以人们也就以七为一个周期来安排自己的工作和生活,而星期日是休息日。从实际的角度来讲,以七为一个周期,长短也比较合适。所以尽管中国...
  • 产品的生命周期

    千次阅读 2018-09-09 20:08:37
    管理学上弗农的产品生命周期理论将产品(商品)的生命周期分为导入期、成长期、成熟期、饱和期、衰退期个阶段。这是个经典的模型,足以概括大部分产品在进入市场直到退出市场的整个生命周期。 但从软件产品经理来...
  • 黑色星期C语言实现

    千次阅读 多人点赞 2018-10-29 22:20:50
    问题描述:已知1998年1月1日是星期4,输入一个1998年之后的年份,输出本年所有的黑色星期5日期。...//可以计算这一天距离已知的98年1月1日有多少天,那天是星期四,天数+3再模7,结果是几就是星期几。是...
  • 其次,知道想算的日子和这个确定的日子之间相差多少天,用7除这个日期的差值,余数就表示想算的日子的星期在确定的日子的星期之后多少天。如果余数是0,就表示这两天的星期相同。显然,如果把这个作为“原点”的日子...
  • 软件生存周期

    千次阅读 2013-05-01 17:59:51
    软件生存周期  软件生存周期是软件工程学最基本的概念之一。各种各样的开发方法都不同程度地承认这个基本概念。 一、含义  软件生存周期是指:从构思软件产品开始到产品不能再使用时为止的时间周期。软件生存...
  • BUG的生命周期

    千次阅读 2019-06-14 10:23:16
    本篇为【从零开始学产品】...--摘自【修真神界】第三千六百十一章 为了女神写Bug (本书预计在2035年出版) 一什么是BUG的生命周期 世界上本来没有Bug,程序员多了, 就创造出来了Bug了. 程序员为什...
  • 不查日历怎么知道任何一天是星期几作者:刘夙 2004-5-2 1:53:20 博客中国(Blogchina.com) 文/葛民勤---------------------------------------------------------------------------摘要: 最常见的公式:W = [Y...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,696
精华内容 35,078
关键字:

五天周期是多少天