精华内容
下载资源
问答
  • matlab开发-用于验证和优化打印机的平台区域控制器的竞争性心律疗法。我们提出了一种用于APBI中HDR间质近距离放射治疗的剂量验证和优化工具。
  • Problem Description War is the reciprical and violent application of force between hostile political entities aimed at bringing about a desired political end-state via armed conflict....
  • Spark 开发优化

    2018-07-30 03:57:36
    不同houseId(区域)的数据差异很大(如北上广与新疆西藏订单数据),导致清洗产生大量小文件 100G原始文件,清洗后产生10万多个文件 2.数据入库延迟大 因为kafka 不同分区流速差异大,HDFS数据有延迟几个...

    文件存储
    分区规则: /houseId=?/dayId=?/hourId=?/minutet=5(5分钟产生一个文件)
    存在问题:
    1.收敛参数coalesce失效,小文件特别多
    不同houseId(区域)的数据差异很大(如北上广与新疆西藏订单数据),导致清洗产生大量小文件
    100G原始文件,清洗后产生10万多个文件

    2.数据入库延迟大
    因为kafka 不同分区流速差异大,HDFS数据有延迟几个小时,导致spark进行清洗后数据分布在多个时间分区,这也导致小文件


    3.数据倾斜
    不同houseId(省级区域)的数据差异很大,数据量从几兆到20G
    数据倾斜,容易产生较慢的Task,拖累job执行时间,造成集群吞吐降低

    4.清洗效率
    小文件太多,直接导致NameNode压力过大(每个文件150Byte,一千万文件对应大概2G内存)负载过大,清洗效率非常慢


    改造数据清洗流程:

    1.数据入库效率改造
          确保数据入HDFS延时不超过1小时


    2.数据入HDFS目录,按照时间和house分目录:  /${5分钟目录}/${houseId}
           

    3.spark读取数据源目录,遍历5分钟目录的每个house目录
          每个house目录生成一个DataFrame,根据每个house目录的大小确定收敛参数(coalesce)大小为partitionNum
          根据性能考虑,将1小时内数据与1小时前的数据进行分开计算,为其分配合适的分区,提高计算效率,集群吞吐量
          (1) 当前时间1小时的数据,转换为DataFrame ,分区书为partitionNum
          (2) 过滤1小时前的数据,转换为DataFrame ,分区数大小为partitionNum的三分之一

    4.使用union将每个目录生成的DataFrame合并一个DataFrame,将这个DataFrame写入分区


    解决思路:
        根据每个house目录的大小确定收敛参数(coalesce)大小解决了小文件文件(coalesce指定分区,可以避免产生过大小文件,不产生空文件),同时保证收敛后每个分区的数据基本均衡


          
     
    Spark读取中文乱码: 
    spark textFile读取文件,但是该方法只支持UTF-8(面向传输的编码格式数据),不支持GBK(中文自负编码集),处理会产生乱码

    sc.hadoopFile读取每个文件数据,处理数据单元
    通过java  new String(str,offset,str.length,charaSet)


    spark json 解析文件都是面向传输效率高的UTF-8编码,不支持GBK,GB2312,GB18030    
    sc.hadoopFile同样进行数据单元处理,然后转换成RDD,然后进行sparkSession.read.json进行读取RDD

    Spark Streaming监控文件目录开发,问题分析
    1.无法解决小文件问题
    2.spark streaming程序重启数据丢失
    3.大文件入监控目录,入库时间长,spark streaming只会读取部分数据
    生产不建议使用spark streaming监控文件,直接使用flume,filebeat ==> Kafka ===>spark streaming

    Livy(CDH)进行spark任务发布,管理
    优点:
    1.交互式scala,Python,R,shell
    2.多个提交scala,
    3.多个用户可以共享一台server
    4.可用于使用REST,从任何位置提交作业
    5.不需要对程序进行任何代码修改,同spark-submit提交任务代码一样
    6.亮点:共享sparkContext,RDDs(上一次计算的RDD结果,可以被下一个任务利用),避免重复计算,I/O

    启动时:需要配置spark_home,hadoop_home
    进行export 临时导入或者配置文件


    spark 使用REST方式调用优点:
    1.一个spark job值对应一个url,避免混淆
    2.每个资源都是唯一标识,便于编程,抽象成统一API,避免重复开发
    3.通过spark 调度引擎(livy,job server)可以共享sparkcontext,RDD,进而降低作业响应时间,提高集群工作效率,集群吞吐
    4.便于进行程序,使用REST方式,每个资源对应一个URL标识,便于python,java,scala,shell程序开发,不会出现资源对应不一致,错误调用的情况
    5.多任务提交不会出现冲突
     

    展开全文
  • 1) 要及时回收Bitmap的内存 Bitmap类有一个方法recycle(),从方法名可以看出意思是回收。这里就有疑问了,Android系统有自己的垃圾回收机制...所以,加载Bitmap到内存里以后,是包含两部分内存区域的。简单的说,一部分
  • 在Unity中ScrollView功能是单一的滚动区域,但是我们日常游戏开发中,使用ScrollView所需要的功能更像是使用List一样,View中是重复的prefabs组成的,根据数据不同而展示不同内容的item。其实如果不考虑性能及个性的...

    -前言-

    已经好久没有写博客了。最近开始了Unity的开发工作,一开始都是做做UI写写逻辑,目前主要任务就是摸透Unity UI的模块开发。本章就来了解下最近用得笔记多的ScrollView功能。

    在Unity中ScrollView功能是单一的滚动区域,但是我们日常游戏开发中,使用ScrollView所需要的功能更像是使用List一样,View中是重复的prefabs组成的,根据数据不同而展示不同内容的item。其实如果不考虑性能及个性的优化的话,自己认为Unity的ScrollView功能非常强大,并且搭配自动布局就能很轻松的实现所需要的功能。

    -正文-

    -不考虑性能的实现方式-

    首先在场景中新建一个ScrollView组件,Unity会自动为我们生成如图

    Content是我们元素添加的根节点,我们可以通过GameObject实例化Prefabs添加到Content中。添加逻辑也没什么好说。说下两个注意的点:

    1.由于滚动内容是根据Content的高度自适应出来的,因此在我们往Content下添加子节点时,需要更新Content的高度,有个不需要我们计算的方式,是在Content上挂载ContentSizeFitter脚本

    2.根据需求挂载自适应脚本,GridLayoutGroup、VerticalLayoutGroup、HorizontalLayoutGroup这三个选中其中一个适用实际开发的,设置好参数即可。

    问题

    用上面方式做有个很大的问题是:

    1.渲染压力:对于不显示的Item Unity也会记性计算渲染,虽然我暂时不知道UnityUI渲染步骤,但是ScrollView是使用的Mask遮罩,Mask一般是会计算并提交渲染的,只是在顶点着色器中被裁剪

    2.计算压力:如果ScrollView是一个玩家背包,背包数据可能有1000条,如果实例在1、2帧中同时处理这么多数据及UI赋值,是非常卡的,很影响游戏体验,如果特殊情况不做优化一般就需要添加进度条。

    优化方式

    对于ScrollView的优化方式不管什么引擎、语言都是差不多的,就是根据当前Bar的值去计算一个Viewport视窗内展示item所需源数据区间。下面的代码是基于x-lua框架写的,并且只实现了Vertical滑动,意思都差不多,能够领悟到就行。

    实现这个ScrollView我们就区别于原有的名字,命名为ListView,只是骨子里还是ScrollView。

    1.创建ListView数据

    local list_db = {
        -- 布局信息
        Layout = {
            Padding = {
                Left = 10,
                Right = 10,
                Top = 30,
                Bottom = 30
            },
            CellSize = {
                x = 170, y = 174
            },
            Spacing = {
                x = 10, y = 10
            }
        },
        -- prefabs路径
        PrefabsPath = false,
        -- 逻辑类
        LogicClass = false
    }

    这个ListView需要如同Unity自带的Layout布局信息,方便在设置item的时候设置坐标。

    2.创建ListView

    -- 创建
    UIListView.OnCreate = function(self, list_model)
        base.OnCreate(self)
    
        self.unity_scroll_view = UIUtil.FindComponent(self.transform, typeof(CS.UnityEngine.UI.ScrollRect))
        if IsNull(self.unity_scroll_view) then
            Logger.LogError("Unity Scroll View is Null-->??")
        end
        self.content_trans = self.unity_scroll_view.content
        self.unity_scroll_bar = self.unity_scroll_view.verticalScrollbar
        -- 检测item是否加载
        if not GameObjectPool:GetInstance():CheckHasCached(list_model.PrefabsPath) then
            GameObjectPool:GetInstance():CoPreLoadGameObjectAsync(list_model.PrefabsPath, 1)
        end
        self.logic_cls = list_model.LogicClass
        self.render_prefabs_path = list_model.PrefabsPath
        self.cache_prefabs = {}
        self.list_model = list_model
        __InitCalColAndRowNum(self)
    end

    这里的list_model就是上面的list_db的实例

    3.计算viewport内需要的行和列

    -- 计算有多少列
    local function __InitCalColAndRowNum(self)
        --计算列
        local layout = self.list_model.Layout
        local valid_width = self.content_trans.rect.width - layout.Padding.Left - layout.Padding.Right
        local valid_height = self.unity_scroll_view.viewport.rect.height - layout.Padding.Top - layout.Padding.Bottom
        -- 列
        self.col = Mathf.Floor(valid_width / (layout.CellSize.x + layout.Spacing.x))
        -- 最大实例化出来的行数,超过的动态算
        self.max_row = Mathf.Ceil((valid_height + layout.Spacing.y) / (layout.CellSize.y + layout.Spacing.y))
        self.valid_height = valid_height
    end

    因为这里的Vertical方向,因此列是固定的,max_row就是viewport中能容纳的最大行,这个行列相乘就是最少需要的Prefabs个数

    4.设置数据源datasource

    列表是通过数据驱动的,有多少数据再算出需要多少Item,因此这里是根据外部传进来的datasource,这里就不关系数据类型是什么,但要求是一个数组。

    -- 计算列表高度
    local function __CalContentHeight(self)
        local layout = self.list_model.Layout
        local total_row = Mathf.Ceil(#self.data_source / self.col)
        local height = total_row * (layout.CellSize.y + layout.Spacing.y) + layout.Padding.Top + layout.Padding.Bottom - layout.Spacing.y
        self.content_trans.sizeDelta  = Vector2.New(0,height)
        self.total_row = total_row
    end
    
    -- 刷新list
    local function __Refresh(self)
        local new_index_vec = __CalDataIndexIntervalByScrollbarValue(self)
        if self.index_vec == new_index_vec then
            return
        end
        self.index_vec = new_index_vec
        --__MoveAllToCache(self)
        if not self.using_prefabs then
            self.using_prefabs = {}
        end
        local layout = self.list_model.Layout
        local item_index = 1
        local allFromUsing = true
        for index = new_index_vec.x, new_index_vec.y do
            local data = self.data_source[index]
            local item
            if allFromUsing and #self.using_prefabs > item_index then
                item = self.using_prefabs[item_index]
                item_index = item_index + 1
                if self.render_handler then
                    self.render_handler:RunWith(item,data)
                end
            elseif #self.cache_prefabs > 0 then
                allFromUsing = false
                item = table.remove(self.cache_prefabs, 1)
                item:SetActive(true)
                if self.render_handler then
                    self.render_handler:RunWith(item, data)
                end
                table.insert(self.using_prefabs, item)
            else
                allFromUsing = false
                local go = GameObjectPool:GetInstance():GetLoadedGameObject(self.render_prefabs_path)
                if IsNull(go) then
                    Logger.LogError("UIListView GetLoadedGameObject Fail-->>Path:" .. self.render_prefabs_path)
                    return
                end
                local go_trans = go.transform
                go_trans:SetParent(self.content_trans)
                go_trans.anchorMin = Vector2.New(0,1)
                go_trans.anchorMax = Vector3.New(0,1)
                go_trans.localPosition = Vector3.zero
                go_trans.localScale = Vector3.one
                go_trans.name = self.logic_cls.__cname .. tostring(RenderItemCnt)
                RenderItemCnt = RenderItemCnt + 1
                item = self:AddComponent(self.logic_cls, go)
                item.transform.sizeDelta = Vector2.New(layout.CellSize.x,layout.CellSize.y)
                if self.render_handler then
                    self.render_handler:RunWith(item, data)
                end
                item:SetActive(true)
                table.insert(self.using_prefabs, item)
            end
            item.transform.anchoredPosition = Vector2.New(__CalPositionByIndex(self,index))
        end
        if allFromUsing and #self.using_prefabs > item_index then
            for i = item_index, #self.using_prefabs do
                local tmp_item = self.using_prefabs[item_index]
                table.remove(self.using_prefabs,item_index)
                table.insert(self.cache_prefabs,tmp_item)
            end
        end
    end

    首先通过datasource的数组长度计算出需要设置的content的高度,功能与ContentSizeFitter类似,只是这里是自己算出来的。接下来就刷新列表,首先需要根据当前scrollbar的value计算出datasource的起点index与终点index,计算方式如下

    local function __CalDataIndexIntervalByScrollbarValue(self)
        local start_row = Mathf.Floor((1 - self.scroll_value) * self.total_row)
        local end_row = start_row + self.max_row
        local start_index = (start_row - 3) * self.col + 1
        local end_index = end_row * self.col
        if start_index < 1 then
            start_index = 1
        end
        if end_index > #self.data_source then
            local diff = end_index - #self.data_source
            end_index = #self.data_source
            start_index = start_index - diff
            if start_index < 1 then
                start_index = 1
            end
        end
        return Vector2.New(start_index,end_index)
    end

    首先我们知道总共需要多少行,根据value就可以得出当前处于多少行,再加上viewport内容需要多少行,转换为index即可。

    5.根据数据的index计算坐标

    -- 通过index计算坐标
    local function __CalPositionByIndex(self,index)
        local layout = self.list_model.Layout
        local col = (index - 1) % self.col
        local row = Mathf.Floor((index - 1) / self.col)
        local x = col * (layout.CellSize.x + layout.Spacing.x) + layout.Padding.Left + layout.CellSize.x / 2
        local y = row * (layout.CellSize.y + layout.Spacing.y) + layout.Padding.Top + layout.CellSize.y / 2
        y = y * -1
        return x,y
    end

    这里就需要用到之前list_db中的布局数据进行设置具体的坐标

    6.回调渲染

    设置好后就可以通过之前设置的一个render函数,回调回ListView的持有方,告诉它我用什么item用上了什么数据,让它来拿着这个数据和item对象来做些逻辑。

     

    完~

    自己也是才学Unity没多久,也在摸索,如果有什么问题欢迎指正,谢谢~

    展开全文
  • 前言 不管是日常开发,还是面试,我们都会和内存打交道,因为内存是支持软件运行的基本硬件环境。了解Android 内存管理,就有必要了解Java GC机制,必须要理解JVM 内存区域,这里我们主要从概念上介绍Java虚拟机内存...
    • 前言    

    不管是日常开发,还是面试,我们都会和内存打交道,因为内存是支持软件运行的基本硬件环境。了解Android 内存管理,就有必要了解Java GC机制,必须要理解JVM 内存区域,这里我们主要从概念上介绍Java虚拟机内存的各个区域。


    • 认识Java内存区域组成

    Java虚拟机在执行程序过程中会把管理的内存划分为不同的数据区域,包括方法区、堆内存、虚拟机栈、本地方法栈、程序计数器这5个部分的运行时数据区。


    • 程序计数器

    在计算机组成原理里,CPU内部的寄存器中就包含一个程序计数器,存放程序执行的下一条指令地址。 

    依照特定机器的细节而不同,他可能是保存着正在被运行的指令,也可能是下一个要运行指令的地址。程序计数器在每个指令周期会自动地增加,所以指令会正常地从寄存器中连续地被取出。某些指令,像是跳跃和子程序调用,会中断程序执行的序列,将新的数值内容存放到程序计数器中。 
    在大部分的处理器,指令指针都是在提取程序指令后就被立即增加;也就是说跳跃指令的目的地址,是由跳跃指令的运算对象加上跳跃指令之后下一个指令的地址(比特或字节,视电脑形态而定)来获得目的地。

    而我们的JVM内存中的程序计数器也是这样的作用,它储存JVM当前执行bytecode的地址。

    Java虚拟机中的程序计数器是Java运行时数据区中的一小块内存区域,但是它的功能和通常的程序计数器是类似的,它指向虚拟机正在执行字节码指令的地址。具体点儿说,当虚拟机执行的方法不是native的时,程序计数器指向虚拟机正在执行字节码指令的地址;当虚拟机执行的方法是native的时,程序计数器中的值是未定义的。另外,程序计数器是线程私有的,也就是说,每一个线程都拥有仅属于自己的程序计数器

    此内存区域是唯一一个在 Java 虚拟机规范 
    中没有规定任何 OutOfMemoryError 情况的区域。


    • 虚拟机栈(JVM Stack)

    与程序计数器一样,Java 虚拟机栈(Java Virtual Machine Stacks)也是线程私有的,它的生命周期与 线程相同。虚拟机栈描述的是 Java 方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(Stack Frame)用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程, 
    就对应着一个栈帧在 虚拟机栈中从入栈到出栈的过程。

    局部变量表存放了编译期可知的各种基本数据类型(boolean、byte、char、short、int、float、long、 double)、对象引用(reference 类型),它不等同于对象本身,根据不同的虚拟机实现,它可能是一个指向 4 / 31 
    对象起始地址的引用指针,也可能指向一个代表对象的句柄或者其他与此对象相关的位置)和 returnAddress 
    类型(指向了一条字节码指令的地址)。 
    其中 64 位长度的 long 和 double 类型的数据会占用 2 个局部变量空间(Slot),其余的数据类型只占 用 1 个。局部变量表所需的内存空间在编译期间完成分配,当进入一个方法时,这个方法需要在帧中分配多大 的局部变量空间是完全确定的,在方法运行期间不会改变局部变量表的大小。 在 Java 虚拟机规范中,对这个 区域规定了两种异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出 StackOverflowError 异 
    常;如果虚拟机栈可以动态扩展(当前大部分的 Java 虚拟机都可动态扩展,只不过 Java 虚拟机规范中也允许 
    固定长度的虚拟机栈),当扩展时无法申请到足够的内存时会抛出 OutOfMemoryError 异常。


    • 本地方法栈(Native Method Statck)

    本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的,其区别不过是虚拟机栈为 
    虚拟机执行 Java 方法(也就是字节码)服务,而本地方法栈则是为虚拟机使用到的 Native 方法服务。虚拟机 规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定,因此具体的虚拟机可以自由实 现它。甚至有的虚拟机(譬如 Sun HotSpot 虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一 

    样,本地方法栈区域也会抛出 StackOverflowError 和 OutOfMemoryError 异常。


    • 堆区(Heap)

    对于大多数应用来说,Java 堆(Java Heap)是 Java 虚拟机所管理的内存中最大的一块。Java 堆是被所 有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存 放对象实例 ,几乎所有的对象 实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是:所有的对象实例以及数组都要在堆上分配,但 是随着 JIT 编译器的发展与逃逸分析技术的逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化发 生,所有的对象都分配在堆上也渐渐变得不是那么“绝对”了。 
    Java 堆是垃圾收集器管理的主要区域,因此很多时候也被称做“GC 堆”(Garbage Collected Heap,幸 
    好国内没翻译成“垃圾堆”)。如果从内存回收的角度看,由于现在收集器基本都是采用的分 代 收 集 算法,所以 Java 堆中还可以细分为:新生代和老年代;再细致一点的有 Eden 空间、From Survivor 空间、To Survivor 空间等。如果从内存分配的角度看,线程共享的 Java 堆中可能划分出多个线程私有的分配缓冲区(Thread 
    Local Allocation Buffer,TLAB)。不过,无论如何划分,都与存放内容无关,无论哪个区域,存储的都仍然 是对象实例,进一步划分的目的是为了更好地回收内存,或者更快地分配内存。在本章中,我们仅仅针对内存区 
    域的作用进行讨论,Java 堆中的上述各个区域的分配和回收等细节将会是下一章的主题。 
    根据 Java 虚拟机规范的规定,Java 堆可以处于物理上不连续的内存空间中,只要逻辑上是连续的即可, 就像我们的磁盘空间一样。在实现时,既可以实现成固定大小的,也可以是可扩展的,不过当前主流的虚拟机都 
    是按照可扩展来实现的(通过-Xmx 和-Xms 控制)。如果在堆中没有内存完成实例分配,并且堆也无法再扩展 时,将会抛出 OutOfMemoryError 异常。

    堆内存唯一目的就是存放创建的对象实例,所有对象实例和数组都要在这里分配内存,因此也是垃圾回收的主要区域。根据虚拟机规范,java堆可以在物理空间上不连续,只要逻辑上连续即可,当堆内存无法继续分配时会抛出OutOfMemery异常。




    • 方法区(Method Area)

    方法区(Method Area)与 Java 堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类 
    信息、常量、静态变量、即时编译器编译后的代码等数据。虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑 部分,但是它却有一个别名叫做 Non-Heap(非堆),目的应该是与 Java 堆区分开来。

    对于习惯在 HotSpot 虚拟机上开发和部署程序的开发者来说,很多人愿意把方法区称为“永久 代”Permanent Generation),本质上两者并不等价,仅仅是因为 HotSpot 虚拟机的设计团队选择把 GC 分 
    代收集扩展至方法区,或者说使用永久代来实现方法区而已。对于其他虚拟机(如 BEA JRockit、IBM J9 等) 来说是不存在永久代的概念的。即使是 HotSpot 虚拟机本身,根据官方发布的路线图信息,现在也有放弃永久 代并“搬家”至 Native Memory 来实现方法区的规划了。 
    Java 虚拟机规范对这个区域的限制非常宽松,除了和 Java 堆一样不需要连续的内存和可以选择固定大小 
    或者可扩展外,还可以选择不实现垃圾收集。相对而言,垃圾收集行为在这个区域是比较少出现的,但并非数据 
    进入了方法区就如永久代的名字一样“永久”存在了。这个区域的内存回收目标 主要是针对常量池的回收和对类型 的卸载,一般来说这个区域的回收“成绩”比较难以令人满意,尤其是类型的卸载,条件相当苛刻,但是这部分区 
    域的回收确实是有必要的。在 Sun 公司的 BUG 列表中, 曾出现过的若干个严重的 BUG 就是由于低版本的 
    HotSpot 虚拟机对此区域未完全回收而导致内存泄漏。 根据 Java 虚拟机规范的规定,当方法区无法满足内存 分配需求时,将抛出 OutOfMemoryError 异常。

    用于存储被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码数据等。Java虚拟机规范把方法区描述为堆的一个逻辑部分。 
    运行时常量池是方法区的一部分,Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项就是常量池,用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池中存放。



    • 运行时常量池

    运行时常量池(Runtime Constant Pool)是方法区的一部分。Class 文件中除了有类的版本、字段、 方法、接口等描述等信息外,还有一项信息是常量池(Constant Pool Table),用于存放编译期生成的各种字 面量和符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中。 Java 虚拟机对 Class 文件的每 一部分(自然也包括常量池)的格式都有严格的规定,每一个字节用于存储哪种数据都必须符合规范上的要求, 这样才会被虚拟机认可、装载和执行。但对于运行时常量池,Java 虚拟机规范没有做任何细节的要求,不同的 提供商实现的虚拟机可以按照自己的需要来实现这个内存区域。不过,一般来说,除了保存 Class 文件中描述 的符号引用外,还会把翻译出来的直接引用也存储在运行时常量池中。 运行时常量池相对于 Class 文件常量池 
    的另外一个重要特征是具备动态性,Java 语言并不要求常量一定只能在编译期产生,也就是并非预置入 Class 文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性被开发人员 

    利用得比较多的便是 String 类的 intern()方法。 既然运行时常量池是方法区的一部分,自然会受到方法区内 存的限制,当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。



    • 运行时常量池与Class文件常量池区别
    1. JVM对Class文件中每一部分的格式都有严格的要求,每一个字节用于存储那种数据都必须符合规范上的要求才会被虚拟机认可、装载和执行;但运行时常量池没有这些限制,除了保存Class文件中描述的符号引用,还会把翻译出来的直接引用也存储在运行时常量区
    2. 相较于Class文件常量池,运行时常量池更具动态性,在运行期间也可以将新的变量放入常量池中,而不是一定要在编译时确定的常量才能放入。最主要的运用便是String类的intern()方法


    • 对象的创建

    以上我们介绍了5个数据区域,三个是线程隔离的,它们有:Java虚拟机栈,本地方法栈,程序计数器。另外还有两个数据区域是线程共享的,这两个区域是垃圾回收发生的地方,它们分别是:堆,方法区。

    我们最常见的也是最简单的创建对象有以下几种方式:

    通过这种方式我们可以调用任意的构造函数(无参的和有参的)去创建对象。

    Object object = new Object();
    • 1

    使用Class类的newInstance方法(反射机制) 
      
    Student stu = Student.class.newInstance(); 

    new 指令时主要涉及一些一个过程:

    • 检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过
    • 类加载检查通过
    • 虚拟机java堆为新主对象分配内存,对象所需内存的大小在类加载完成后确定
    • 虚拟机将分配到的内存空间都初始化为零值
    • 设置对象头,对象头中存储了该对象是拿了类的实例等信息
    • 执行 init 方法,把对象初始化

    new指令工作流程如下图:




    • 对象的访问

    介绍完 Java 虚拟机的运行时数据区之后,我们就可以来探讨一个问题:在 Java 语言中,对象访问是如何 进行的?对象访问在 Java 语言中无处不在,是最普通的程序行为,但即使是最简单的访问,也会却涉及 Java 
    栈、Java 堆、方法区这三个最重要内存区域之间的关联关系,如下面的这句代码: Object obj = new Object(); 
    假设这句代码出现在方法体中,那“Object obj”这部分的语义将会反映到 Java 栈的本地变量表中,作为一个 reference 类型数据出现。而“new Object()”这部分的语义将会反映到 Java 堆中,形成一块存储了 Object 类型所有实例数据值(Instance Data,对象中各个实例字段的数据)的结构化内存,根据具体类型以及虚拟机 实现的对象内存布局(Object Memory Layout)的不同,这块内存的长度是不固定的。另外,在 Java 堆中 

    还必须包含能查找到此对象类型数据(如对象类型、父类、实现的接口、方法等)的地址信息,这些类型数据则 存储在方法区中。


    • 句柄方式

    如果使用句柄访问方式,Java 堆中将会划分出一块内存 来作为句柄池,reference 中存储的就是对象的句柄地址,而句柄中包含了对象实例数据和类型数据各自的具体地址信息




    • 直接指针方式
      如果使用的是直接指针访问方式,Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息, 

    reference 中直接存储的就是对象地址




    这两种对象的访问方式各有优势,使用句柄访问方式的最大好处就是 reference 中存储的是稳定的句柄地 址,在对象被移动(垃圾收集时移动对象是非常普遍的行为)时只会改变句柄中的实例数据指针,而 reference 
    本 身 不 需要被修改。 使用直接指针访问方式的最大好处就 是速度更快,它节省了一次指针定位 的时间开销,由 于对象的访问在 Java 中非常频繁,因此这类开销积少成多后也是一项非常可观的执行成本。就本书讨论的主 

    要虚拟机 Sun HotSpot 而言,它是使用第二种方式进行对象访问的,但从整个软件开发的范围来看,各种语言 和框架使用句柄来访问的情况也十分常见。


    总结

    上面说了那么说,下面来个简单的概括:

    • 方法区:方法区存放的是类信息、常量、静态变量,所有线程共享区域。

    • 虚拟机栈:它的生命周期与 线程相同,每个方法在执行的同时都会创建一个栈帧(Stack Frame)用存储局部变量表、操作数栈、动态链接、方法出口等信息,线程私有区域。

    • 本地方法栈:与虚拟机栈类似,区别是虚拟机栈为虚拟机执行Java方法服务,本地方法栈为虚拟机使用到的Native方法。

    • :线程共享;用来存放对象实例,几乎所有的对象实例都在堆上分配内存;此区域也是垃圾回收器(Garbage Collection)主要的作用区域,内存泄漏就发生在这个区域。

    • 程序计数器:用于指示当前线程所执行的字节码执行到了第几行,可以理解为是当前线程的行号指示器。如果线程在执行Java方法,这个计数器记录的是正在执行的虚拟机字节码指令地址。


    非常感谢fuchenxuan的 Android 性能优化 之谈谈Java内存区域一文,讲的非常仔细,大家可以去看看。

    通过上面的学习,我们了解了JVM的内存区域,和java 对象的基本创建和访问方式,了解了Java内存,接下来就会就内存检露分析,gcroot原理,Dalvik内存分配策略和内存管理,Android性能优化之线上OOM分析和避免OOM


    敬请关注后续几篇:

    1. 内存检露分析
    2. Dalvik内存分配策略和内存管理
    3. gcroot原理
    4. Android性能优化之线上OOM分析和避免OOM



    展开全文
  • 了解Android 内存管理,就有必要了解Java GC机制,必须要理解JVM 内存区域,这里我们主要从概念上介绍Java虚拟机内存的各个区域。 Android 应用运行时大部分时间都用于处理内存数据,虽然很多开发...

    最近一年副业主要在学习投资和技能学习,把以前学习内存分析的一些笔记总结发出来,写了很多笔记总结都没有写完就又忙着了,最近再次总结复习学习一遍,还有提醒各位同学一定要学会投资。。

    了解Android 内存管理,就有必要了解Java GC机制,必须要理解JVM 内存区域,这里我们主要从概念上介绍Java虚拟机内存的各个区域。

    Android 应用运行时大部分时间都用于处理内存数据,虽然很多开发者都意识到优化内存,但并不是所有人都知道内存使用对性能的影响,网上也有很多关于内存优化技术的文章,但大多都不够系统,没有贯通全局。在《Android 性能优化之String篇》文中我们理解了一个对象占用空间的大小以及String 字符串对我们性能的影响,而在本文中我们将学习一些Android的内存,主要是基础的java 的内存管理,Java程序在运行的过程中管理的内存的数据区,为后面的Android内存分析做为铺垫。
    在阅读过程中有任何问题,请及时联系。如需转载请注明 fuchenxuan blog
    本章系《Android 之美 从0到1 – 高手之路》Android 性能优化 之深入理解Java内存结构。

    Java 内存区域

    Java虚拟机在执行程序过程中会把管理的内存划分为不同的数据区域,包括方法区、堆、虚拟机栈、本地方法栈、程序计数器这5个部分的运行时数据区。如下图:

    程序计数器

    在计算机组成原理里,CPU内部的寄存器中就包含一个程序计数器,存放程序执行的下一条指令地址。
    以下引自wiki的一段介绍。

    依照特定机器的细节而不同,他可能是保存着正在被运行的指令,也可能是下一个要运行指令的地址。程序计数器在每个指令周期会自动地增加,所以指令会正常地从寄存器中连续地被取出。某些指令,像是跳跃和子程序调用,会中断程序执行的序列,将新的数值内容存放到程序计数器中。
    在大部分的处理器,指令指针都是在提取程序指令后就被立即增加;也就是说跳跃指令的目的地址,是由跳跃指令的运算对象加上跳跃指令之后下一个指令的地址(比特或字节,视电脑形态而定)来获得目的地。

    而我们的JVM内存中的程序计数器也是这样的作用,它储存JVM当前执行bytecode的地址。

    Java虚拟机中的程序计数器是Java运行时数据区中的一小块内存区域,但是它的功能和通常的程序计数器是类似的,它指向虚拟机正在执行字节码指令的地址。具体点儿说,当虚拟机执行的方法不是native的时,程序计数器指向虚拟机正在执行字节码指令的地址;当虚拟机执行的方法是native的时,程序计数器中的值是未定义的。另外,程序计数器是线程私有的,也就是说,每一个线程都拥有仅属于自己的程序计数器

    此内存区域是唯一一个在 Java 虚拟机规范
    中没有规定任何 OutOfMemoryError 情况的区域。

    虚拟机栈(JVM Stack)

    与程序计数器一样,Java 虚拟机栈(Java Virtual Machine Stacks)也是线程私有的,它的生命周期与 线程相同。虚拟机栈描述的是 Java 方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(Stack Frame)用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程,
    就对应着一个栈帧在 虚拟机栈中从入栈到出栈的过程。

    局部变量表存放了编译期可知的各种基本数据类型(boolean、byte、char、short、int、float、long、 double)、对象引用(reference 类型),它不等同于对象本身,根据不同的虚拟机实现,它可能是一个指向 4 / 31
    对象起始地址的引用指针,也可能指向一个代表对象的句柄或者其他与此对象相关的位置)和 returnAddress
    类型(指向了一条字节码指令的地址)。
    其中 64 位长度的 long 和 double 类型的数据会占用 2 个局部变量空间(Slot),其余的数据类型只占 用 1 个。局部变量表所需的内存空间在编译期间完成分配,当进入一个方法时,这个方法需要在帧中分配多大 的局部变量空间是完全确定的,在方法运行期间不会改变局部变量表的大小。 在 Java 虚拟机规范中,对这个 区域规定了两种异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出 StackOverflowError 异
    常;如果虚拟机栈可以动态扩展(当前大部分的 Java 虚拟机都可动态扩展,只不过 Java 虚拟机规范中也允许
    固定长度的虚拟机栈),当扩展时无法申请到足够的内存时会抛出 OutOfMemoryError 异常。

    本地方法栈(Native Method Statck)

    本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的,其区别不过是虚拟机栈为
    虚拟机执行 Java 方法(也就是字节码)服务,而本地方法栈则是为虚拟机使用到的 Native 方法服务。虚拟机 规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定,因此具体的虚拟机可以自由实 现它。甚至有的虚拟机(譬如 Sun HotSpot 虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一
    样,本地方法栈区域也会抛出 StackOverflowError 和 OutOfMemoryError 异常。

    堆区(Heap)

    对于大多数应用来说,Java 堆(Java Heap)是 Java 虚拟机所管理的内存中最大的一块。Java 堆是被所 有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存 放对象实例 ,几乎所有的对象 实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是:所有的对象实例以及数组都要在堆上分配,但 是随着 JIT 编译器的发展与逃逸分析技术的逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化发 生,所有的对象都分配在堆上也渐渐变得不是那么“绝对”了。
    Java 堆是垃圾收集器管理的主要区域,因此很多时候也被称做“GC 堆”(Garbage Collected Heap,幸
    好国内没翻译成“垃圾堆”)。如果从内存回收的角度看,由于现在收集器基本都是采用的分 代 收 集 算法,所以 Java 堆中还可以细分为:新生代和老年代;再细致一点的有 Eden 空间、From Survivor 空间、To Survivor 空间等。如果从内存分配的角度看,线程共享的 Java 堆中可能划分出多个线程私有的分配缓冲区(Thread
    Local Allocation Buffer,TLAB)。不过,无论如何划分,都与存放内容无关,无论哪个区域,存储的都仍然 是对象实例,进一步划分的目的是为了更好地回收内存,或者更快地分配内存。在本章中,我们仅仅针对内存区
    域的作用进行讨论,Java 堆中的上述各个区域的分配和回收等细节将会是下一章的主题。
    根据 Java 虚拟机规范的规定,Java 堆可以处于物理上不连续的内存空间中,只要逻辑上是连续的即可, 就像我们的磁盘空间一样。在实现时,既可以实现成固定大小的,也可以是可扩展的,不过当前主流的虚拟机都
    是按照可扩展来实现的(通过-Xmx 和-Xms 控制)。如果在堆中没有内存完成实例分配,并且堆也无法再扩展 时,将会抛出 OutOfMemoryError 异常。

    堆内存唯一目的就是存放创建的对象实例,所有对象实例和数组都要在这里分配内存,因此也是垃圾回收的主要区域。根据虚拟机规范,java堆可以在物理空间上不连续,只要逻辑上连续即可,当堆内存无法继续分配时会抛出OutOfMemery异常。

    方法区(Method Area)

    方法区(Method Area)与 Java 堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类
    信息、常量、静态变量、即时编译器编译后的代码等数据。虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑 部分,但是它却有一个别名叫做 Non-Heap(非堆),目的应该是与 Java 堆区分开来。

    对于习惯在 HotSpot 虚拟机上开发和部署程序的开发者来说,很多人愿意把方法区称为“永久 代”Permanent Generation),本质上两者并不等价,仅仅是因为 HotSpot 虚拟机的设计团队选择把 GC 分
    代收集扩展至方法区,或者说使用永久代来实现方法区而已。对于其他虚拟机(如 BEA JRockit、IBM J9 等) 来说是不存在永久代的概念的。即使是 HotSpot 虚拟机本身,根据官方发布的路线图信息,现在也有放弃永久 代并“搬家”至 Native Memory 来实现方法区的规划了。
    Java 虚拟机规范对这个区域的限制非常宽松,除了和 Java 堆一样不需要连续的内存和可以选择固定大小
    或者可扩展外,还可以选择不实现垃圾收集。相对而言,垃圾收集行为在这个区域是比较少出现的,但并非数据
    进入了方法区就如永久代的名字一样“永久”存在了。这个区域的内存回收目标 主要是针对常量池的回收和对类型 的卸载,一般来说这个区域的回收“成绩”比较难以令人满意,尤其是类型的卸载,条件相当苛刻,但是这部分区
    域的回收确实是有必要的。在 Sun 公司的 BUG 列表中, 曾出现过的若干个严重的 BUG 就是由于低版本的
    HotSpot 虚拟机对此区域未完全回收而导致内存泄漏。 根据 Java 虚拟机规范的规定,当方法区无法满足内存 分配需求时,将抛出 OutOfMemoryError 异常。

    用于存储被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码数据等。Java虚拟机规范把方法区描述为堆的一个逻辑部分。
    运行时常量池是方法区的一部分,Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项就是常量池,用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池中存放。

    运行时常量池

    运行时常量池(Runtime Constant Pool)是方法区的一部分。Class 文件中除了有类的版本、字段、 方法、接口等描述等信息外,还有一项信息是常量池(Constant Pool Table),用于存放编译期生成的各种字 面量和符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中。 Java 虚拟机对 Class 文件的每 一部分(自然也包括常量池)的格式都有严格的规定,每一个字节用于存储哪种数据都必须符合规范上的要求, 这样才会被虚拟机认可、装载和执行。但对于运行时常量池,Java 虚拟机规范没有做任何细节的要求,不同的 提供商实现的虚拟机可以按照自己的需要来实现这个内存区域。不过,一般来说,除了保存 Class 文件中描述 的符号引用外,还会把翻译出来的直接引用也存储在运行时常量池中。 运行时常量池相对于 Class 文件常量池
    的另外一个重要特征是具备动态性,Java 语言并不要求常量一定只能在编译期产生,也就是并非预置入 Class 文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性被开发人员
    利用得比较多的便是 String 类的 intern()方法。 既然运行时常量池是方法区的一部分,自然会受到方法区内 存的限制,当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。

    运行时常量池与Class文件常量池区别

    • JVM对Class文件中每一部分的格式都有严格的要求,每一个字节用于存储那种数据都必须符合规范上的要求才会被虚拟机认可、装载和执行;但运行时常量池没有这些限制,除了保存Class文件中描述的符号引用,还会把翻译出来的直接引用也存储在运行时常量区

    • 相较于Class文件常量池,运行时常量池更具动态性,在运行期间也可以将新的变量放入常量池中,而不是一定要在编译时确定的常量才能放入。最主要的运用便是String类的intern()方法

    对象的创建

    以上我们介绍了5个数据区域,三个是线程隔离的,它们有:Java虚拟机栈,本地方法栈,程序计数器。另外还有两个数据区域是线程共享的,这两个区域是垃圾回收发生的地方,它们分别是:堆,方法区。

    我们最常见的也是最简单的创建对象有以下几种方式:

    通过这种方式我们可以调用任意的构造函数(无参的和有参的)去创建对象。

    Object object = new Object();
    • 1

    使用Class类的newInstance方法(反射机制)
     
    Student stu = Student.class.newInstance();

    new 指令时主要涉及一些一个过程:

    • 检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过
    • 类加载检查通过
    • 虚拟机java堆为新主对象分配内存,对象所需内存的大小在类加载完成后确定
    • 虚拟机将分配到的内存空间都初始化为零值
    • 设置对象头,对象头中存储了该对象是拿了类的实例等信息
    • 执行 init 方法,把对象初始化

    这里写图片描述

    对象的访问

    介绍完 Java 虚拟机的运行时数据区之后,我们就可以来探讨一个问题:在 Java 语言中,对象访问是如何 进行的?对象访问在 Java 语言中无处不在,是最普通的程序行为,但即使是最简单的访问,也会却涉及 Java
    栈、Java 堆、方法区这三个最重要内存区域之间的关联关系,如下面的这句代码: Object obj = new Object();
    假设这句代码出现在方法体中,那“Object obj”这部分的语义将会反映到 Java 栈的本地变量表中,作为一个 reference 类型数据出现。而“new Object()”这部分的语义将会反映到 Java 堆中,形成一块存储了 Object 类型所有实例数据值(Instance Data,对象中各个实例字段的数据)的结构化内存,根据具体类型以及虚拟机 实现的对象内存布局(Object Memory Layout)的不同,这块内存的长度是不固定的。另外,在 Java 堆中
    还必须包含能查找到此对象类型数据(如对象类型、父类、实现的接口、方法等)的地址信息,这些类型数据则 存储在方法区中。

    句柄方式

    如果使用句柄访问方式,Java 堆中将会划分出一块内存 来作为句柄池,reference 中存储的就是对象的句柄地址,而句柄中包含了对象实例数据和类型数据各自的具体地址信息

    这里写图片描述

    直接指针方式

    如果使用的是直接指针访问方式,Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息,
    reference 中直接存储的就是对象地址

    这里写图片描述

    这两种对象的访问方式各有优势,使用句柄访问方式的最大好处就是 reference 中存储的是稳定的句柄地 址,在对象被移动(垃圾收集时移动对象是非常普遍的行为)时只会改变句柄中的实例数据指针,而 reference
    本 身 不 需要被修改。 使用直接指针访问方式的最大好处就 是速度更快,它节省了一次指针定位 的时间开销,由 于对象的访问在 Java 中非常频繁,因此这类开销积少成多后也是一项非常可观的执行成本。就本书讨论的主
    要虚拟机 Sun HotSpot 而言,它是使用第二种方式进行对象访问的,但从整个软件开发的范围来看,各种语言 和框架使用句柄来访问的情况也十分常见。

    总结

    上面说了那么说,下面来个简单的概括:

    • 方法区:方法区存放的是类信息、常量、静态变量,所有线程共享区域。

    • 虚拟机栈:它的生命周期与 线程相同,每个方法在执行的同时都会创建一个栈帧(Stack Frame)用存储局部变量表、操作数栈、动态链接、方法出口等信息,线程私有区域。

    • 本地方法栈:与虚拟机栈类似,区别是虚拟机栈为虚拟机执行Java方法服务,本地方法栈为虚拟机使用到的Native方法。

    • :线程共享;用来存放对象实例,几乎所有的对象实例都在堆上分配内存;此区域也是垃圾回收器(Garbage Collection)主要的作用区域,内存泄漏就发生在这个区域。

    • 程序计数器:用于指示当前线程所执行的字节码执行到了第几行,可以理解为是当前线程的行号指示器。如果线程在执行Java方法,这个计数器记录的是正在执行的虚拟机字节码指令地址。

    通过上面的学习,我们了解了JVM的内存区域,和java 对象的基本创建和访问方式。为我们后面线上OOM 分析、Dalvik内存管理学习做铺垫,以及分析线上各种OOM 的原因以及如何去解决。

    后面几篇文章:

    1.Android 性能优化 之谈谈Java内存区域
    2.Android 性能优化 之了解Dalvik内存分配策略
    3.Android 性能优化 之内存泄漏分析
    4.Android 性能优化 之Dalvik内存管理、线上OOM分析总结

    更多Android 之美,请阅读《Android 之美 从0到1 – 高手之路》系列文章

    水平有限,若有错漏,欢迎指正,批评,如需转载,请注明出处–http://blog.csdn.net/vfush,谢谢!

    Android 之美 从0到1

    展开全文
  • 在做移动端前端开发过程中,我们经常会遇到滚动区域,而在ios和android上,滚动区域的表现也不一样,例如滚动条的样子就不一样,有图有真相 所以第一步:统一长相! 在移动端(特别在微信端),浏览器对css新属性...
  • 因为这个是面试必问的,在这做再一次的总结,希望能...能用一个控件完成不用两个控件避免过度绘制在多层次重叠的UI结构里面,如果不可见的UI也在做绘制操作,会导致某些像素区域被绘制了多次,这个主要是针对背景,...
  • 考虑到煤矿区不同区域地面煤层气开发目的不同,从煤层气井产能与经济两个方面,优化了研究区内地面煤层气开发井网部署。研究表明:1区内井网布置形式采用矩形法,考虑到构造、煤田钻孔及地形地貌因素,局部可采用不规则...
  • @[WEB的高并发分布式架构以及优化] 一般来说,解决WEB高并发的有效手段都是采用可线性扩展的多层分布式架构 Webserver (Nginx) :这一层是可以轻松分布式部署的,结合智能DNS解析可以简易地防止单点故障、实现区域...
  • 通过对区域物流网络中边、点上费用、容量、流量等的分析,结合实际问题中对道路扩建和物流设施容量设计决策的需要,构建基于物流时间需求的区域物流网络设计数学模型。模型以最小化物流网络构建成本、初期运营成本和...
  • 区域还要再细化10几个小区域,要将这些雷电数据关联到这些小区域 进一步细化 采用CSV的格式导入 数据量最多为50w 没有明确的时效性要求,但可能是用户在那等着看 基本实现路线 由于有大量数据要在地图上显示,因此...
  • 开发者选项中打开Overdraw,尽量减少红色区域,增加蓝色区域 开发者选项打开Profile GPU Rendering,确保现状图大部分在绿色横线下 尽量少用透明度,带透明度的view会至少渲染两次 2.内存优化工具:Memory Monitor,...
  • 根据CCRD结果,开发了RSM和ANN模型,优化了生物表面活性剂的生产。 RSM模型的相关系数(R2)解释了底物浓度之间相互作用的DW的88%和CB的73%,而ANN模型的DW的99%和CB的相互作用说明了99%,这表明已开发的ANN...
  • 针对数据导入(N个)这一工功能,里面有一个关键步骤是数据从数十个区域(R个)中做空间匹配寻找所处的区域,我们上次讨论了三个版本的优化,如下所示: 第一个版本是直接插入版本 第二个版本是批量插入版本再修改 第三...
  •  这篇主要总结一些优化代码的技巧,一些写代码中的小细节,可能就会影响程序的执行效率!!! 主要遵循两个原则 1.不要创建一些没必要创建的对象以及重复定义某个变量 对象的创建是一个非常繁琐的步骤,JVM首先...
  • 转载地址:卡顿 卡顿的原因: 由上面屏幕显示的原理,采用了垂直同步机制的手机设备。如果在一个VSync 时间内...通过子线程监测主线程的runLoop,判断结束休眠到再次休眠两个状态区域之间的耗时是否达到一定阈值。 (2
  • 基于RKNN开发 搭建开发环境 训练自己的数据 基于Darknet开发 展望 人工智能开发系列(3) YOLOV3开发与实现 一、概述 物体检测 传统的人工设计特征加浅层分类器 基于深度学习检测框架 R-CNN:候选区域选择CNN特征提取...
  • 优化轨迹 区域描述和定位 使用建议 常见案例 使用区域学习和 ADF原文链接:https://developers.google.com/tango/overview/area-learning工作原理单用运动追踪,设备可以追踪自己在 3D 空间中的运动和方向,也能...
  • GPU过度绘制指的是在屏幕一个像素上绘制多次(超过一次),比如一个TextView后有背景,那么显示文本的像素至少绘了...开启后,启动我们的应用,可以看到各种颜色的区域,其中: 蓝色 1x过度绘制 绿色 2x过度绘制 淡红色
  • 触碰区域优化 设计师切图切大点,多余部分变成透明色 前端将可触碰区域变大 解决向左箭头变灰,向右变灰 禁用事件的技巧 产生一个向左的事件,但是在nav组件里面忽略 组件自身判断是否是第一期,自身禁用向左的...
  • 达妹收集了一些在Web开发中容易出错和被忽略的小问题,并且提供了参考的解决方案,以便于帮助Web开发者更好的完善网站。 通过避免下面这些小错误,可以使得我们的网站变得更为友好。 错误1:表单的label标签跟表单...
  • Android开发界面显示慢-过度绘制优化

    千次阅读 2017-02-06 10:42:14
    作者名:残剑 ...如果一个布局十分复杂,那么就需要来排查是否出现了过度绘制,如果出现了,那么很可能会造成刷新率...过度绘制就是在同一个区域中叠加了多个控件。这就像小时候我们画画,白纸就是没有绘制的画板
  • 没有使用主窗体的区域重绘技术,而是使用一个Label组件来展现截取的图片区域,所以在拖拽将截取区域变小或者是反向截图的时候,闪烁及卡顿的现象会比较严重,这里针对这两个问题对行一些针对性的优化。 启用双缓冲 ...
  • 【摘要】为在车身开发过程中提高车门关闭舒适性,建立了车门静态关闭力计算模型,推导出密封条反力的工程计算方法,结合某车型车门关闭困难问题,从密封条压缩载荷特性和压缩量角度详细分析问题原因,制定了改善措施...
  • 没有使用主窗体的区域重绘技术,而是使用一个Label组件来展现截取的图片区域,所以在拖拽将截取区域变小或者是反向截图的时候,闪烁及卡顿的现象会比较严重,这里针对这两个问题对行一些针对性的优化。 C#双缓冲...
  • Java语言最重要的特点之一:跨平台使用,正是由于JVM的存在。想要Java开发稳步进阶,学JVM这条路绕不开。 1.为什么要学JVM? 我们都知道,要做Java开发,必须在你...怎么优化? 2.JVM是什么? JVM,即Java Virtual Mac

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 708
精华内容 283
关键字:

优化开发区域