java内存分配,final作用

SAP 角色继承、派生 角色继承、派生 继承:是指两个角色Role形成母子关系。子角色的所有菜单、授权都源于母角色,并与母角色保持一致。母角色与子角色是1对多的关系。 继承关系:新建子角色继承母角色中的事务(后续通过复制,将母角色授权数据复制至子角色) 派生概念:将母角色中的授权数据派生至子角色中。 业务场景:方便批量修改子角色权限。若有继承关系,只需要修改母角色,然后通过母角色派生功能,从而批量修改子角色授权数... 阅读详情

1. java中内存的分配

java程序在运行时,内存结构分为:方法区(method),栈内存(stack),堆内存(heap),本地方法栈(java中的jni调用)等。

jvm为每一个运行的线程分配一个堆栈(方法栈),堆栈以帧为单位来保存线程的运行的状态,java中,我们将当前正在运行的方法称为当前方法,当java激活(执行)一个方法时,就会向堆栈中压入一个帧,堆栈中的这一帧就代表这个方法在运行时jvm为它分配的内存,这一帧叫做当前帧,帧里可以存放方法的参数,中间结果和局部变量等。当当前方法执行完时,当前帧也会出栈,即该内存区域被释放。方法栈中只会存放基本类型数据和对象的引用。

基础数据类型直接在栈空间分配,方法的形式参数,直接在栈空间分配,当方法调用完成后从栈空间回收。引用数据类型,需要用new来创建,既在栈空间分配一个地址空间,又在堆空间分配对象的类变量 。方法的引用参数,在栈空间分配一个地址空间,并指向堆空间的对象区,当方法调用完成后从栈空间回收。局部变量new出来时,在栈空间和堆空间中分配空间,当局部变量生命周期结束后,栈空间立刻被回收,堆空间区域等待GC回收。方法调用时传入的literal参数,先在栈空间分配,在方法调用完成后从栈空间分配。字符串常量在DATA区域分配,this在堆空间分配。数组既在栈空间分配数组名称,又在堆空间分配数组实际的大小!

image 这个图是错误的,帧并不包括堆内存,存放帧的方法栈是线程私有的,其他线程无法访问的,而存放对象和数组的对内存是多个线程共享的,整个jvm中只有一份。

image

以我目前的水平,只能画到这个程度,还有很多问题没有弄明白。

在进行debug调试的时候,会有一个更直观的表现内存分配的图

image

每一个线程一个自己的堆栈,方法以帧的形式压入栈中。

一个类的全局变量,全局常量有存放在哪呢?

这些信息存放在一个叫做方法区的地方,在每一个jvm的内部,都有一个称为方法去的逻辑存储区。

方法区存放装载的类数据信息包括:
    (1):基本信息:
           1)每个类的全限定名
           2)每个类的直接超类的全限定名(可约束类型转换)
           3)该类是类还是接口
           4)该类型的访问修饰符
           5)直接超接口的全限定名的有序列表
    (2):每个已装载类的详细信息:
           1)运行时常量池: 
             jvm为每个已加载的类型都维护一个常量池。常量池就是这个类型用到的常量的一个有序集合,包括实际的常量(string,
            integer, 和floating point常量)和对类型,域和方法的符号引用。池中的数据项象数组项一样,是通过索引访问的。
             因为常量池存储了一个类型所使用到的所有类型,域和方法的符号引用,所以它在java 程序 的动态链接中起了核心的作用。

           2)字段信息:
              类中声明的每一个字段的信息(字段名,类型,修饰符)。
           3)方法信息:
              类中声明的每一个方法的信息(名,返回类型,参数类型,修饰符,方 法的字节码和异常表)。
           4)静态变量    也就是类变量(class variables)用关键字 static 修饰,在类加载的时候,分配类变量的内存,以后在生成类的实例对象时,将共享这块内存(类变量)  ,任何一个对象对类变 
               量的修改,都会影响其它对象。外部有两种访问方式:通过对象来访问或通过类名来访问。

           5)到类 classloader 的引用:即到该类的类装载器的引用。
           6)到类 class 的引用:
                 虚拟机为每一个被装载的类型创建一个 class 实例, 用来代表这个被装载的类。

方法区是被多个线程所共享的,因此会有线程安全的问题。

编译器将源代码编译成字节码(.class)时, 就已经将各种类型的方法的局部变量, 操作数栈大小确定并放在字节码中,随着类一并装载入方法区。当调用方法时,通过访问方法区中的类的信息,得到局部变量以及操作数栈的大小。 
也就是说: 在方法中定义的一些基本类型的变量和对象的引用变量都在方法的栈内存中分配。 当在一段代码块定义一个变量时,Java 就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java 会自动释放掉为该变量所分配的内存空间,

该内存空间可以立即被另作它用。

问题:方法区的内存在哪分配?

单独的一块内存,他是和堆内存,栈内存平级的内存区域,在一个jvm中,只有一个方法区,多个线程共享。例如,有个set方法,被线程a和线程b执行,set方法存在哪呢,很显然,存放在方法区。那么为什么还要有方法栈呢,也就是存放帧的内存区域,因为方法在执行时,就会被调入线程所在的方法栈呢内,为变量分配空间,计算逻辑等,需要一个区域来存放方法执行时的中间结果啊,需要到的参数啊等等。

问题:类中的属性成员的信息在哪存储?

栈内存和堆内存比较
    栈与堆都是 Java 用来在内存中存放数据的地方。与 C++不同,Java 自动管理栈和堆,程序员不能直接地设置栈或堆。
    Java 的堆是一个运行时数据区,对象从中分配空间。堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java 的垃圾收
集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度 较慢。
    栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的, 缺乏灵活性。栈中主要存放一些基本类型的变量 (int,short, long, byte, float, double, boolean, char)和对象句柄。
    栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:
    int a = 3;
    int b = 3;
    编译器先处理 int a = 3;首先它会在栈中创建一个变量为 a 的引用,然后查找栈中是 否有 3 这个值,如果没找到,就将 3存放进来,然后将 a 指向 3。接着处理 int b = 3;在创建完 b 的引用变量后,
    因为在栈中已经有 3 这个值,便将 b 直接指向 3。这样,就出现了a 与 b 同时均指向 3 的情况。
    这时,如果再令 a=4;那么编译器 会重新搜索栈中是否有 4 值,如果没有,则将 4 存 放进来,并令 a 指向 4;如果已经有了,则直接将 a 指向这个地址。因此 a 值的改变不会影响到 b 的值。
    要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况 a 的修改并不会影响到 b, 它是由编译器完成的,它有利于节省空间。此时的内存分配示意图如下:

    而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。

String 的内存分配
    String 是一个特殊的包装类数据。可以用:
    String str = new String("abc");
    String str = "abc";
    两种的形式来创建,第一种是用 new()来新建对象的,它会在存放于堆中。每调用一次 就会创建一个新的对象。
    而第二种是先在栈中创建一个对 String 类的对象引用变量 str,然后查找栈中有没有 存放"abc", 如果没有, 则将"abc"存放进栈, 并令 str 指向”abc”,如果已经有”abc” 则直接令 str 指向“abc”。
    比较类里面的数值是否相等时,用 equals()方法;当测试两个包装类的引用是否指向 同一个对象时,用==,下面用例子说明上面的理论。
    String str1 = "abc";
    String str2 = "abc";
    System.out.println(str1==str2); //true
    可以看出 str1 和 str2 是指向同一个对象的。
       String str1 = new String ("abc");
       String str2 = new String ("abc");
       System.out.println(str1==str2); // false
       用 new 的方式是生成不同的对象。每一次生成一个。
       因此用第一种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已。 这种写法有利于节省内存空间。同时它可以在一定程度上提高程序的运行速度,因为 JVM 会自动根据栈中数据的实际情况来决定是否有必要创建新对象。
       而对于 String str = new String("abc");的代码,则一概在堆中创建新对象,而不管其字符串值是否相等,是否 有必要创建新对象,从而加重了程序的负担。
       另一方面, 要注意: 我们在使用诸如 String str = "abc";的格式时,总是想当然 地认为,创建了 String 类的对象 str。担心陷阱!对象可能并没有被创建!而可能只是指向一个先前已经创建的对象。
       只有通过 new()方法才能保证每次都创建一个新的对象。 由于 String 类的值不可变性(immutable)  ,当 String 变量需要经常变换其值时,应该考虑使用 StringBuffer 或 StringBuilder 类,以提高程序效率。

java程序的执行流程

这两天看了一下深入浅出JVM这本书,推荐给高级的java程序员去看,对你了解JAVA的底层和运行机制有
比较大的帮助。
废话不想讲了.入主题:
先了解具体的概念:
JAVA的JVM的内存可分为3个区:堆(heap)、栈(stack)和方法区(method)
堆区:
1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享,堆中不存放基本类型和对象引用,只存放对象本身
栈区:
1.每个线程包含一个栈区,栈中只保存基础数据类型的对象和自定义对象的引用(不是对象),对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的,其他栈不能访问。
3.栈分为3个部分:基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1.又叫静态区,跟堆一样,被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素,如class,static变量。
为了更清楚地搞明白发生在运行时数据区里的黑幕,我们来准备2个小道具(2个非常简单的小程序)。
AppMain.java
public   class  AppMain                //运行时, jvm 把appmain的信息都放入方法区
{
public   static   void  main(String[] args)  //main 方法本身放入方法区。
{
Sample test1 = new  Sample( " 测试1 " );   //test1是引用,所以放到栈区里, Sample是自定义对象应该放到堆里面
Sample test2 = new  Sample( " 测试2 " );
test1.printName();
test2.printName();
}
} Sample.java
public   class  Sample        //运行时, jvm 把appmain的信息都放入方法区
{
/** 范例名称 */
private  name;      //new Sample实例后, name 引用放入栈区里,  name 对象放入堆里
/** 构造方法 */
public  Sample(String name)
{
this .name = name;
}
/** 输出 */
public   void  printName()   //print方法本身放入 方法区里。
{
System.out.println(name);
}
} OK,让我们开始行动吧,出发指令就是:“java AppMain”,包包里带好我们的行动向导图,Let’s GO!

11-18 工作总结 - 老百姓 - 老百姓 的博客
系统收到了我们发出的指令,启动了一个Java虚拟机进程,这个进程首先从classpath中找到AppMain.class文件,读取这个文件中的二进制数据,然后把Appmain类的类信息存放到运行时数据区的方法区中。这一过程称为AppMain类的加载过程。
接着,Java虚拟机定位到方法区中AppMain类的Main()方法的字节码,开始执行它的指令。这个main()方法的第一条语句就是:
Sample test1=new Sample("测试1");
语句很简单啦,就是让java虚拟机创建一个Sample实例,并且呢,使引用变量test1引用这个实例。貌似小case一桩哦,就让我们来跟踪一下Java虚拟机,看看它究竟是怎么来执行这个任务的:
1、 Java虚拟机一看,不就是建立一个Sample实例吗,简单,于是就直奔方法区而去,先找到Sample类的类型信息再说。结果呢,嘿嘿,没找到@@,这会儿的方法区里还没有Sample类呢。可Java虚拟机也不是一根筋的笨蛋,于是,它发扬“自己动手,丰衣足食”的作风,立马加载了Sample类,把Sample类的类型信息存放在方法区里。
2、 好啦,资料找到了,下面就开始干活啦。Java虚拟机做的第一件事情就是在堆区中为一个新的Sample实例分配内存, 这个Sample实例持有着指向方法区的Sample类的类型信息的引用。这里所说的引用,实际上指的是Sample类的类型信息在方法区中的内存地址,其实,就是有点类似于C语言里的指针啦~~,而这个地址呢,就存放了在Sample实例的数据区里。
3、 在JAVA虚拟机进程中,每个线程都会拥有一个方法调用栈,用来跟踪线程运行中一系列的方法调用过程,栈中的每一个元素就被称为栈帧,每当线程调用一个方法的时候就会向方法栈压入一个新帧。这里的帧用来存储方法的参数、局部变量和运算过程中的临时数据。OK,原理讲完了,就让我们来继续我们的跟踪行动!位于“=”前的Test1是一个在main()方法中定义的变量,可见,它是一个局部变量,因此,它被会添加到了执行main()方法的主线程的JAVA方法调用栈中。而“=”将把这个test1变量指向堆区中的Sample实例,也就是说,它持有指向Sample实例的引用。
OK,到这里为止呢,JAVA虚拟机就完成了这个简单语句的执行任务。参考我们的行动向导图,我们终于初步摸清了JAVA虚拟机的一点点底细了,COOL!
接下来,JAVA虚拟机将继续执行后续指令,在堆区里继续创建另一个Sample实例,然后依次执行它们的printName()方法。当JAVA虚拟机执行test1.printName()方法时,JAVA虚拟机根据局部变量test1持有的引用,定位到堆区中的Sample实例,再根据Sample实例持有的引用,定位到方法去中Sample类的类型信息,从而获得printName()方法的字节码,接着执行printName()方法包含的指令。

2. final关键字的使用总结

     2. 1 final关键字修饰的变量的作用域

             final关键字无非修饰两种变量,一是全局变量,当修饰全局变量的时候,作用域自然是全局,另一种是修饰局部变量,这里要注意,java中不同于c语言中,即时使用final修饰了局部变量,并没有改变该变量的作用域,当这个方法执行完毕之后,就会释放掉这个方法的帧内存。变量就被销毁了,堆里的对象等待gc回收。

    2.2 final类型的初始化

           第一种情况:作为全局常量来使用,定义的时候就要进行显示初始化,如果定义的时候不进行显示初始化,则必须在构造函数里进行初始化。

class Student {
    String name;
    int age;
    final Teacher tc;
    public void study(){
    }
    public Student(String name,int age){
        tc = new Teacher();
    }
    public Student(){
        this(null, 0);
    }
}
class Teacher{
    int num;
    String name;
    int age;
}

第二种情况,在函数中使用,

public void startThread(){
        final Student stumain = new Student();
        final Teacher teacher;
        new Thread(new Runnable(){
            @Override
            public void run() {
                stumain.study();
teacher = new Teacher();//这行代码是报错的
            }
        }).start();
    }

2.3 在函数中什么情况下要使用final修饰局部变量?

当在一个函数中,你需要使用全局变量时,可以新建一个final类型的变量,并将全局变量的引用赋给这个final变量,因为局部变量时存放在方法栈里的,寻址速度比较快。

此外,当在函数A中调用函数B时,如果函数B的函数体不是很大,将函数B声明为final类型的,编译器在编译的时候,会直接将函数B的函数体内嵌在函数A中调用函数B的地方。

例如:

见下面的测试代码,我会执行五次:

  1. public class Test  
  2. {  
  3. public static void getJava()  
  4.     {  
  5.         String str1 = "Java ";  
  6.         String str2 = "final ";  
  7. for (int i = 0; i < 10000; i++)  
  8.         {  
  9.             str1 += str2;  
  10.         }  
  11.     }  
  12. public static final void getJava_Final()  
  13.     {  
  14.         String str1 = "Java ";  
  15.         String str2 = "final ";  
  16. for (int i = 0; i < 10000; i++)  
  17.         {  
  18.             str1 += str2;  
  19.         }  
  20.     }  
  21. public static void main(String[] args)  
  22.     {  
  23. long start = System.currentTimeMillis();  
  24.         getJava();  
  25.         System.out.println("调用不带final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");  
  26.         start = System.currentTimeMillis();  
  27.         String str1 = "Java ";  
  28.         String str2 = "final ";  
  29. for (int i = 0; i < 10000; i++)  
  30.         {  
  31.             str1 += str2;  
  32.         }  
  33.         System.out.println("正常的执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");  
  34.         start = System.currentTimeMillis();  
  35.         getJava_Final();  
  36.         System.out.println("调用final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");  
  37.     }  
  38. } 

结果为:
第一次:
调用不带final修饰的方法执行时间为:1732毫秒时间
正常的执行时间为:1498毫秒时间
调用final修饰的方法执行时间为:1593毫秒时间
第二次:
调用不带final修饰的方法执行时间为:1217毫秒时间
正常的执行时间为:1031毫秒时间
调用final修饰的方法执行时间为:1124毫秒时间
第三次:
调用不带final修饰的方法执行时间为:1154毫秒时间
正常的执行时间为:1140毫秒时间
调用final修饰的方法执行时间为:1202毫秒时间
第四次:
调用不带final修饰的方法执行时间为:1139毫秒时间
正常的执行时间为:999毫秒时间
调用final修饰的方法执行时间为:1092毫秒时间
第五次:
调用不带final修饰的方法执行时间为:1186毫秒时间
正常的执行时间为:1030毫秒时间
调用final修饰的方法执行时间为:1109毫秒时间 
由以上运行结果不难看出,执行最快的是“正常的执行”即代码直接编写,而使用final修饰的方法,不像有些书上或者文章上所说的那样,速度与效率与“正常的执行”无异,而是位于第二位,最差的是调用不加final修饰的方法。

2.4 函数中使用final修饰的变量的声明周期

当函数体结束后,该变量是否依旧存在?

public static void main(String[] args) {

    final Integer x = 50;
    new Thread(new Runnable() {
        @Override
        public void run() {
            while (x > 0) {
    断点2:   System.out.println("the x is: " + x);
                try {
                    Thread.sleep(1*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }).start();

   断点1: System.out.println("the main is over: *********************************************************"
                + Thread.currentThread().getId() + "");
}

打印结果:

the main is over: *********************************************************1
the x is: 50
the x is: 50
the x is: 50
the x is: 50
the x is: 50
the x is: 50
the x is: 50
the x is: 50
the x is: 50
the x is: 50

main方法执行完后,x应该销毁了啊,那么自然子线程也应该停止,但是为什么子线程没有停止呢?

打断点,进行debug调试,在断点1首先停了下来,查看变量

image

F8跳转到断点2,这时候主线程已经结束

image

对比两张图会发现,主线程和子线程中的两个x根本不是一个,也就是说匿名内部类中自己维护了一个变量的引用。和方法中的变量x指向同一个对象。

匿名内部类把需要访问的外部变量作为一个隐藏的字段,这样得到了一个变量的引用拷贝 ,使用final修饰符不仅会保持对象不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期。

用final关键字修饰对象变量,只是不允许这个对象引用再指向其他的对象,但是这个引用所指向的对象的内容是可以改变的。例如下面代码:

public static void main(String[] args) {

        final ArrayList<Integer> list = new ArrayList<Integer>();
        ArrayList<Integer> list02 = new ArrayList<Integer>();
        for(int x=0;x<100;x++){
            list.add(x);
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(Integer in:list){
                    System.out.println(Thread.currentThread().getId()+":"+in);
                }
            }
        }).start();
        list.add(101);
        list.add(1002);
        list.add(1003);
        list.add(1004);
        System.out.println("main thread is over");
    }

打印结果:

main thread is over
8:0
8:1
8:2

.

.

.

8:99
8:101
8:1002
8:1003
8:1004

2.5 方法中的匿名内部类使用到了方法中的局部变量

编译器规定,方法中的匿名内部类在使用方法内的局部变量的时候,局部变量必须由final关键字修饰

我们先来看GC工作原理,JVM中每个进程都会有多个根,每个static变量,方法参数,局部变量,当然这都是指引用类型. 基础类型是不能作为根的,根其实就是一个存储地址. GC在工作时先从根开始遍历它引用的对象并标记它们,如此递归到最末梢,所有根都遍历后,没有被标记到的对象说明没 有被引用,那么就是可以被回收的对象(有些对象有finalized方法,虽然没有引用,但JVM中有一个专门的队列引用它们直到finalized方法被执行后才从该队列中移除成为真正没有引用的对象,可以回收,)

       但是在内部类的回调方法中,s既不可能是静态变量,也不是方法中的临时变量,也不是方法参数,它不可能作为根,在内部类 中也没有变量引用它,它的根在内部类外部的那个方法中,如果这时外面变量重指向其它对象,则这个对象就失去了引用, 可能被回收,而由于内部类回调方法大多数在其它线程中执行,可能还要在回收后还会继续访问它.这将是什么结果?
匿名内部类把需要访问的外部变量作为一个隐藏的字段,这样得到了一个变量的引用拷贝 ,使用final修饰符不仅会保持对象不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期。所以这才是final 变量和final参数的根本意义。

推荐系统(十六):基于ESMM的商品召回/推荐系统 ESMM(Entire Space Multi-Task Model)是阿里巴巴提出的多任务学习框架,通过联合建模点击率(CTR)和点击转化率(CVR)解决传统CVR模型样本稀疏问题。其核心思想是将 CVR 定义为 CTR 与 CTCVR 的条件概率,模型包含两个子任务。 阅读详情

相关推荐

Swift Package Manager (SPM) 创建并集成本地库

Swift Package Manager (SPM) 在macOS 项目中创建并集成的完整步骤

征战无悔人生 1428

java 内存分配 final关键字 匿名内部类

1. java中内存的分配 java程序在运行时,内存结构分为:方法区(method),栈内存(stack),堆内存(heap),本地方法栈(java中的jni调用)等。 jvm为每一个运行的线程分配一个堆栈(方法栈),堆栈以帧为单位来保存线程的运行的状态,java中,我们将当前正在运行的方法称为当前方法,当java激活(执行)一个方法时,就会向堆栈中压入一个帧,堆栈中的这一帧就代表这个方...

weixin_30335353的博客 356

【ISP图像处理】Demosaic去马赛克技术演进与边缘优化策略

本文深入解析了ISP图像处理中的Demosaic(去马赛克)技术。从Bayer阵列原理出发,梳理了从双线性插值、Hamilton-Adams边缘导向算法到利用通道相关性与自相似性的技术演进历程,并重点探讨了针对边缘与纹理伪影的优化策略,为工程实践中的算法选型与硬件协同设计提供了专业指导。

weixin_29091445的博客 390

深入分析Java中finalize方法的作用和底层原理

我们手动调用多少次不影响JVM的行为 若JVM检测到finalized状态的对象变成unreachable,回收其内存(I),若对象并未覆盖finalize方法,JVM会进行优化,直接回收对象(O)执行finalize方法完毕后,GC会再次判断该对象是否可达,若不可达,则进行回收,否则,对象“复活”。大致描述一下finalize的运行流程:当对象变成(GC Roots)不可达时,GC会判断该对象是否覆盖了finalize方法,若未覆盖,则直接将其回收。

m0_71777195的博客 1039

把群晖NAS变成游戏开发服务器:Perforce与虚幻引擎深度整合的5个关键配置(含.p4ignore模板)

本文详细介绍了如何将群晖NAS配置为游戏开发服务器,重点讲解了Perforce与虚幻引擎的深度整合。通过五个关键配置节点,包括用户权限架构、Workspace策略、资产同步优化、仓库清洁度保障和编辑器深度集成,帮助小型团队打造高效开发环境。文章还提供了实用的.p4ignore模板和优化技巧,显著提升开发效率。

weixin_30430677的博客 319

Trae+Playwright MCP自动化测试全流程指南:从环境搭建到智能体运行

本文提供了一份详细的Trae与Playwright MCP集成指南,涵盖从Node.js、Python环境搭建到智能体创建的全流程。通过结合MCP协议,AI智能体能够理解任务并驱动Playwright执行复杂的浏览器自动化操作,实现从网页数据抓取到端到端测试的智能工作流。

banana的博客 531

java的finalized作用

object的finalized方法 此方法在垃圾回收时被调用,用于回收资源时的处理 注意点 1、System包含三个静态变量:PrintStream out、InputStream in 和 PrintStream err。 2、InputStream.read()会等待读取输入流,或者等待超时才会返回,进而导致线程阻塞 3、调用gc垃圾回收时,需要使主线程阻塞从而有足够的时间给gc回收线程进行垃圾回收 ...

qhjkdifjfkdlsm的博客 587

[ 虚拟专用网 ] IPsce 虚拟局域网(安全的IP协议的虚拟专用网)详解(二) --- 安全联盟SA

???? 博主介绍 ????‍???? 博主介绍:大家好,我是_PowerShell,很高兴认识大家~ ✨主攻领域:【渗透领域】【数据通信】 【通讯安全】 【web安全】【面试分析】 ????点赞➕评论➕收藏 == 养成习惯(一键三连)???? ????欢迎关注????一起学习????一起讨论⭐️一起进步????文末有彩蛋 ????作者水平有限,欢迎各位大佬指点,相互学习进步! 目录 ???? 博主介绍 一、什么是安全联盟 二、协商参数两种方式:(手动、IKE) 1. 手动 2.

qq_51577576的博客 2802

java gc回收机制_Java中的GC回收机制

为什么要进行GC回收?当我们新建一个对象时,系统就会为其分配一定的内存空间,而有时候新建的对象没有去使用时,不回收的话会极大浪费内存空间,造成系统效率低下。什么时候进行GC回收?1、当CPU空闲的时候2、执行System.gc()方法的时候3、堆内存满了以后GC的算法有引用计数法和可达性分析的算法进行回收引用计数法:当新建对象就创建一个与之对应的计数器,当对象被使用时计数器就加一,而当不执行此对象...

weixin_34231219的博客 695

python爬取银行年报2

python爬取公司年报(巨潮资讯网)

bboysteed的博客 4731

华为OD机试真题 新系统 9月16号 【园区基站节能部署规划】

华为OD机试真题 新系统【园区基站节能部署规划】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题 【园区基站节能部署规划】多语言题解。

qq_45776114的博客 365

static java 内存_final, static,final static 分别放在jvm内存的什么地方?

比如我写一个类:publicclassJvmTest{publicstaticStringst_static="hellostatic";publicfinalStringst_final="hellofinal";publicstaticfinalStringst_final_str="hellofinalstatic";publicstatic...

weixin_39946327的博客 4113

循环神经网络(RNN)原理及BPTT算法

因循环神经网络基于ANN之上,理解ANN有助于理解RNN,所以阅读此文,建议先阅读。

L 1770

JVM—堆栈 堆 方法区 静态区 final static 内存分配

原文作者:一夜丶鱼龙舞 原文地址:JAVA 堆栈 堆 方法区 静态区 final static 内存分配 详解(转) 一、栈(stack)和堆(heap) (1)内存分配的策略 按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的、栈式的、和堆式的. 静态存储分配:是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们..

sanmi8276的博客 1300

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

java变量和常量

变量 开辟一个内存空间,指定一个类型。说白了就是弄个盒子,指定放入特定类型物品(数据)。 java中每个变量属于一种类型(type),数据类型决定了内存分配 变量核心知识:声明、使用、内存分配,作用域。 语法: type 变量名 //声明一个计数器 int count =0; 命名规则不再赘述,驼峰,不能包含关键字。 变量声明和初始化可以一起做,也可以分开做,但是不要使用未初始化的变量。 常量 这...

JDIT的博客 179

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Java 中内存分配情况

一、内存分配区域如下: 1. 内存分配时涉及的区域: 寄存器:在程序中无法控制; 栈:存放基本类型的数据和对象的引用,但是对象本身不存放在栈中,而是存放在堆中; 堆:存放用new产生的数据; 静态域:存放在对象中用static定义的静态成员; 常量池: 存放常量。...

chensiwu7100的博客 211

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Java中的final

一 概念 在Java中, 可以使用final关键字修饰类、方法以及成员变量。 1 final标记的类不能被继承在设计类时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会载被扩展,那么就设计为final类。 2 final标记的方法不能被子类重写① 把方法锁定,防止任何继承类修改它的意义和实现 ② 高效。编译器在遇到调用final方法时候会转入内嵌机制,...

数据库天地 150

java中final变量_java中的final变量

【java中为什么会有final变量】:final这个关键字的含义是“这是无法改变的”或者“终态的”;那么为什么要阻止改变呢?java语言的发明者可能由于两个目的而阻止改变:1).效率问题:jdk中的某些类的某些方法,是不允许被用户覆盖的,设计者可能认为,所用方法已经是最好的方法,用户私自覆盖,或是由于疏忽而覆盖,就会影响JVM或是系统的系能;2). 设计所需:众所周知,有些情况必须使用final...

weixin_39928106的博客 196

java final 内存泄露_Java中的内存处理机制和final、static、final static总结

装载自:http://blog.youkuaiyun.com/wqthaha/article/details/20923579Java程序运行在JVM上,可以把JVM理解成Java程序和操作系统之间的桥梁,JVM实现了Java的平台无关性,由此可见JVM的重要性。所以在学习Java内存分配原理的时候一定要牢记这一切都是在JVM中进行的,JVM是内存分配原理的基础与前提。一个完整的Java程序运行过程会涉及以下...

weixin_30390951的博客 174

Java中的内存处理机制和final、static、final static总结

Java程序运行在JVM上,可以把JVM理解成Java程序和操作系统之间的桥梁,JVM实现了Java的平台无关性,由此可见JVM的重要性。所以在学习Java内存分配原理的时候一定要牢记这一切都是在JVM中进行的,JVM是内存分配原理的基础与前提。        一个完整的Java程序运行过程会涉及以下内存区域:         寄存器: JVM内部虚拟寄存器,存取速度非常快,程序不可控制。    ...

weixin_38316999的博客 632

java每日二题1、final的作用?2、String s = “java“与String s = new String(“java“)

1、final的作用? final修饰类,该类不能被继承、不可变 final修饰方法,该方法不能被重写 final修饰变量,该变量不可被修改 final修饰引用类型,该引用类型不能改变地址(即改变指向) 下面的代码是可以的: final Student student = new Student(1,"Andy"); student.setAge(18);//注意,这个是可以的! 2、String s = "java"与String s = new String(“java”) String s = “j

weixin_42118981的博客 204

final关键字_一文了解 final 关键字的特性、使用方法以及实现原理

点击关注上方“Java技术江湖”,设为“置顶或星标”,第一时间送达技术干货。目录final使用final变量final修饰基本数据类型变量和引用final类final关键字的知识点final关键字的最佳实践final的用法关于空白finalfinal内存分配使用final修饰方法会提高速度和效率吗使用final修饰变量会让变量的值不能被改变吗;如何保证数组内部不被修改final方法的三条...

weixin_39969006的博客 353

Java中的static和final的作用区别

3.访问方式不同: 4.在内存中的存在: 5.修饰范围不同: 6.是否常量:

aahdjdb的博客 230

java 中的 final 变量

【java中为什么会有final变量】: final这个关键字的含义是“这是无法改变的”或者“终态的”; 那么为什么要阻止改变呢? java语言的发明者可能由于两个目的而阻止改变: 1).效率问题: ...

49

Java关键字static 和final基础一

点击(此处)折叠或打开 package com.pp; public class StaticFinal { static int a =9 ;//成员变量:static成...

llllanlovePay的博客 105

关于final的一些事情

1.关于final的一些事情 一个Java关键字 1.当其一个类变量没有加该修饰符的时候的一个效果: private static int i = 847; ​ public static void main(String[] args) { System.out.println(i); i = 888; System.out.println(i); } 执行结果: 这个结果应该都懂得,这里就不解释了。 当加上一个final之后,是一个什么样的效果...

第二颗大白菜 535
上一篇: ubuntu 11.04下android开发环境的搭建!
下一篇: 一个合格的程序员应该读过哪些书
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值