`
grzrt
  • 浏览: 188818 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

浅谈java内存模型

    博客分类:
  • JAVA
 
阅读更多

 不同的平台,内存模型是不一样的,但是jvm的内存模型规范是统一的。其实java的多线程并发问题最终都会反映在java的内存模型上,所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型 ,要解决两个主要的问题:可见性和有序性
我们都知道计算机有高速缓存的存在,处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型,屏蔽了底层平台内存管理细节,对于java开发人员,要清楚在jvm内存模型的基础上,如果解决多线程的可见性和有序性。
       那么,何谓可见性? 多个线程之间是不能互相传递数据通信的,它们之间的沟通只能通过共享变量来进行。 Java内存模型(JMM)规定了jvm有主内存,主内存是多个线程共享的 。当new一个对象的时候,也是被分配在主内存中,每个线程都有自己的工作内存,工作内存存储了主存的某些对象的副本,当然线程的工作内存大小是有限制的。当线程操作某个对象时,执行顺序如下:
 (1) 从主存复制变量到当前工作内存 (read and load)
 (2) 执行代码,改变共享变量值 (use and assign)
 (3) 用工作内存数据刷新主存相关内容 (store and write)

JVM规范定义了线程对主存的操作指令:read,load,use,assign,store,write。当一个共享变量在多个线程的工作内存中都有副本时,如果一个线程修改了这个共享变量,那么其他线程应该能够看到这个被修改后的值,这就是多线程的可见性问题。
        那么,什么是有序性呢 ?线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完 成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。
        线程不能直接为主存中中字段赋值,它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write),至于何时同步过去,根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线 程会引用该变量副本,当同一线程多次重复对字段赋值时,比如:

 

Java代码 复制代码  收藏代码
  1. for ( int  i= 0 ;i< 10 ;i++)   
  2.  a++;  

 

 


线程有可能只对工作内存中的副本进行赋 值,只到最后一次赋值后才同步到主存储区,所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x,线程a执行 x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作,它的执行过程如下:
1 从主存中读取变量x副本到工作内存
2 给x加1
3 将x加1后的值写回主

如果另外一个线程b执行x=x-1,执行过程如下:
1 从主存中读取变量x副本到工作内存
2 给x减1
3 将x减1后的值写回主存

那么显然,最终的x的值是不可靠的。假设x现在为10,线程a加1,线程b减1,从表面上看,似乎最终x还是为10,但是多线程情况下会有这种情况发生:
1:线程a从主存读取x副本到工作内存,工作内存中x值为10
2:线程b从主存读取x副本到工作内存,工作内存中x值为10
3:线程a将工作内存中x加1,工作内存中x值为11
4:线程a将x提交主存中,主存中x为11
5:线程b将工作内存中x值减1,工作内存中x值为9
6:线程b将x提交到中主存中,主存中x为9

同样,x有可能为11,如果x是一个银行账户,线程a存款,线程b扣款,显然这样是有严重问题的,要解决这个问题,必须保证线程a和线程b是有序执行的,并且每个线程执行的加1或减1是一个原子操作。看看下面代码:

 

Java代码 复制代码  收藏代码
  1. public   class  Account {   
  2.   
  3.      private   int  balance;   
  4.   
  5.      public  Account( int  balance) {   
  6.          this .balance = balance;   
  7.     }   
  8.   
  9.      public   int  getBalance() {   
  10.          return  balance;   
  11.     }   
  12.   
  13.      public   void  add( int  num) {   
  14.         balance = balance + num;   
  15.     }   
  16.   
  17.      public   void  withdraw( int  num) {   
  18.         balance = balance - num;   
  19.     }   
  20.   
  21.      public   static   void  main(String[] args)  throws  InterruptedException {   
  22.         Account account =  new  Account( 1000 );   
  23.         Thread a =  new  Thread( new  AddThread(account,  20 ),  "add" );   
  24.         Thread b =  new  Thread( new  WithdrawThread(account,  20 ),  "withdraw" );   
  25.         a.start();   
  26.         b.start();   
  27.         a.join();   
  28.         b.join();   
  29.         System.out.println(account.getBalance());   
  30.     }   
  31.   
  32.      static   class  AddThread  implements  Runnable {   
  33.         Account account;   
  34.          int      amount;   
  35.   
  36.          public  AddThread(Account account,  int  amount) {   
  37.              this .account = account;   
  38.              this .amount = amount;   
  39.         }   
  40.   
  41.          public   void  run() {   
  42.              for  ( int  i =  0 ; i <  200000 ; i++) {   
  43.                 account.add(amount);   
  44.             }   
  45.         }   
  46.     }   
  47.   
  48.      static   class  WithdrawThread  implements  Runnable {   
  49.         Account account;   
  50.          int      amount;   
  51.   
  52.          public  WithdrawThread(Account account,  int  amount) {   
  53.              this .account = account;   
  54.              this .amount = amount;   
  55.         }   
  56.   
  57.          public   void  run() {   
  58.              for  ( int  i =  0 ; i <  100000 ; i++) {   
  59.                 account.withdraw(amount);   
  60.             }   
  61.         }   
  62.     }   
  63. }  

 

 


第一次执行结果为10200,第二次执行 结果为1060,每次执行的结果都是不确定的,因为线程的执行顺序是不可预见的。这是java同步产生的根源,synchronized关键字保证了多个 线程对于同步块是互斥的,synchronized作为一种同步手段,解决java多线程的执行有序性和内存可见性,而volatile关键字之解决多线 程的内存可见性问题。后面将会详细介绍。



synchronized关键字
        上面说了,java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量,这一段代码成为互斥区或临界区,为了保证共享变量的正确性,synchronized标示了临界区。典型的用法如下:

 

Java代码 复制代码  收藏代码
  1. synchronized (锁){   
  2.      临界区代码   
  3. }   

 

 


为了保证银行账户的安全,可以操作账户的方法如下:

 

Java代码 复制代码  收藏代码
  1. public   synchronized   void  add( int  num) {   
  2.      balance = balance + num;   
  3. }   
  4. public   synchronized   void  withdraw( int  num) {   
  5.      balance = balance - num;   
  6. }  

 

 


刚才不是说了synchronized的用法是这样的吗:

 

Java代码 复制代码  收藏代码
  1. synchronized (锁){   
  2. 临界区代码   
  3. }  

 

 


那么对于public synchronized void add(int num)这种情况,意味着什么呢?其实这种情况,锁就是这个方法所在的对象。同理,如果方法是public  static synchronized void add(int num),那么锁就是这个方法所在的class。
        理论上,每个对象都可以做为锁,但一个对象做为锁时,应该被多个线程共享,这样才显得有意义,在并发环境下,一个没有共享的对象作为锁是没有意义的。假如有这样的代码:

 

Java代码 复制代码  收藏代码
  1. public   class  ThreadTest{   
  2.    public   void  test(){   
  3.      Object lock= new  Object();   
  4.       synchronized  (lock){   
  5.          //do something   
  6.      }   
  7.   }   
  8. }  

 

 


lock变量作为一个锁存在根本没有意义,因为它根本不是共享对象,每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock,根本不存在锁竞争。
        每个锁对象都有两个队列,一个是就绪队列,一个是阻塞队列,就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个被线程被唤醒 (notify)后,才会进入到就绪队列,等待cpu的调度。当一开始线程a第一次执行account.add方法时,jvm会检查锁对象account 的就绪队列是否已经有线程在等待,如果有则表明account的锁已经被占用了,由于是第一次运行,account的就绪队列为空,所以线程a获得了锁, 执行account.add方法。如果恰好在这个时候,线程b要执行account.withdraw方法,因为线程a已经获得了锁还没有释放,所以线程 b要进入account的就绪队列,等到得到锁后才可以执行。
一个线程执行临界区代码过程如下:
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见,synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性。


生产者/消费者模式
        生产者/消费者模式其实是一种很经典的线程同步模型,很多时候,并不是光保证多个线程对某共享资源操作的互斥性就够了,往往多个线程之间都是有协作的。
        假设有这样一种情况,有一个桌子,桌子上面有一个盘子,盘子里只能放一颗鸡蛋,A专门往盘子里放鸡蛋,如果盘子里有鸡蛋,则一直等到盘子里没鸡蛋,B专门 从盘子里拿鸡蛋,如果盘子里没鸡蛋,则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区,每次往盘子放鸡蛋应该都是互斥的,A的等待其实就是主动放弃锁,B 等待时还要提醒A放鸡蛋。
如何让线程主动释放锁
很简单,调用锁的wait()方法就好。wait方法是从Object来的,所以任意对象都有这个方法。看这个代码片段:

 

Java代码 复制代码  收藏代码
  1. Object lock= new  Object(); //声明了一个对象作为锁   
  2.     synchronized  (lock) {   
  3.        balance = balance - num;   
  4.         //这里放弃了同步锁,好不容易得到,又放弃了   
  5.        lock.wait();   
  6. }  

 

 


如果一个线程获得了锁lock,进入了同步块,执行lock.wait(),那么这个线程会进入到lock的阻塞队列。如果调用 lock.notify()则会通知阻塞队列的某个线程进入就绪队列。
声明一个盘子,只能放一个鸡蛋

 

Java代码 复制代码  收藏代码
  1. import  java.util.ArrayList;   
  2. import  java.util.List;   
  3.   
  4. public   class  Plate {   
  5.   
  6.     List<Object> eggs =  new  ArrayList<Object>();   
  7.   
  8.      public   synchronized  Object getEgg() {   
  9.          if  (eggs.size() ==  0 ) {   
  10.              try  {   
  11.                 wait();   
  12.             }  catch  (InterruptedException e) {   
  13.             }   
  14.         }   
  15.   
  16.         Object egg = eggs.get( 0 );   
  17.         eggs.clear(); // 清空盘子   
  18.         notify(); // 唤醒阻塞队列的某线程到就绪队列   
  19.         System.out.println( "拿到鸡蛋" );   
  20.          return  egg;   
  21.     }   
  22.   
  23.      public   synchronized   void  putEgg(Object egg) {   
  24.          if  (eggs.size() >  0 ) {   
  25.              try  {   
  26.                 wait();   
  27.             }  catch  (InterruptedException e) {   
  28.             }   
  29.         }   
  30.         eggs.add(egg); // 往盘子里放鸡蛋   
  31.         notify(); // 唤醒阻塞队列的某线程到就绪队列   
  32.         System.out.println( "放入鸡蛋" );   
  33.     }   
  34.        
  35.      static   class  AddThread  extends  Thread{   
  36.          private  Plate plate;   
  37.          private  Object egg= new  Object();   
  38.          public  AddThread(Plate plate){   
  39.              this .plate=plate;   
  40.         }   
  41.            
  42.          public   void  run(){   
  43.              for ( int  i= 0 ;i< 5 ;i++){   
  44.                 plate.putEgg(egg);   
  45.             }   
  46.         }   
  47.     }   
  48.        
  49.      static   class  GetThread  extends  Thread{   
  50.          private  Plate plate;   
  51.          public  GetThread(Plate plate){   
  52.              this .plate=plate;   
  53.         }   
  54.            
  55.          public   void  run(){   
  56.              for ( int  i= 0 ;i< 5 ;i++){   
  57.                 plate.getEgg();   
  58.             }   
  59.         }   
  60.     }   
  61.        
  62.      public   static   void  main(String args[]){   
  63.          try  {   
  64.             Plate plate= new  Plate();   
  65.             Thread add= new  Thread( new  AddThread(plate));   
  66.             Thread get= new  Thread( new  GetThread(plate));   
  67.             add.start();   
  68.             get.start();   
  69.             add.join();   
  70.             get.join();   
  71.         }  catch  (InterruptedException e) {   
  72.             e.printStackTrace();   
  73.         }   
  74.         System.out.println( "测试结束" );   
  75.     }   
  76. }  

 

  执行结果:

 

Html代码 复制代码  收藏代码
  1. 放入鸡蛋   
  2. 拿到鸡蛋   
  3. 放入鸡蛋   
  4. 拿到鸡蛋   
  5. 放入鸡蛋   
  6. 拿到鸡蛋   
  7. 放入鸡蛋   
  8. 拿到鸡蛋   
  9. 放入鸡蛋   
  10. 拿到鸡蛋   
  11. 测试结束  

 

 

 


声明一个Plate对象为plate,被线程A和线程B共享,A专门放鸡蛋,B专门拿鸡蛋。假设
1 开始,A调用plate.putEgg方法,此时eggs.size()为0,因此顺利将鸡蛋放到盘子,还执行了notify()方法,唤醒锁的阻塞队列的线程,此时阻塞队列还没有线程。
2 又有一个A线程对象调用plate.putEgg方法,此时eggs.size()不为0,调用wait()方法,自己进入了锁对象的阻塞队列。
3 此时,来了一个B线程对象,调用plate.getEgg方法,eggs.size()不为0,顺利的拿到了一个鸡蛋,还执行了notify()方法,唤 醒锁的阻塞队列的线程,此时阻塞队列有一个A线程对象,唤醒后,它进入到就绪队列,就绪队列也就它一个,因此马上得到锁,开始往盘子里放鸡蛋,此时盘子是 空的,因此放鸡蛋成功。
4 假设接着来了线程A,就重复2;假设来料线程B,就重复3。

整个过程都保证了放鸡蛋,拿鸡蛋,放鸡蛋,拿鸡蛋。



volatile关键字
       volatile是java提供的一种同步手段,只不过它是轻量级的同步,为什么这么说,因为volatile只能保证多线程的内存可见性,不能保证多线程的执行有序性。 而 最彻底的同步要保证有序性和可见性,例如synchronized。任何被volatile修饰的变量,都不拷贝副本到工作内存,任何修改都及时写在主 存。因此对于Valatile修饰的变量的修改,所有线程马上就能看到,但是volatile不能保证对变量的修改是有序的。什么意思呢?假如有这样的代 码:

 

Java代码 复制代码  收藏代码
  1. public   class  VolatileTest{   
  2.    public   volatile   int  a;   
  3.    public   void  add( int  count){   
  4.        a=a+count;   
  5.   }   
  6. }  

 

 


        当一个VolatileTest对象被多个线程共享,a的值不一定是正确的,因为a=a+count包含了好几步操作,而此时多个线程的执行是无序的,因为没有任何机制来保证多个线程的执行有序性和原子性。volatile存在的意义是,任何线程对a的修改,都会马上被其他线程读取到,因为直接操作主存,没有线程对工作内存和主存的同步。 所以,volatile的使用场景是有限的,在有限的一些情形下可以使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全,必须同时满足下面两个条件:
1)对变量的写操作不依赖于当前值。
2)该变量没有包含在具有其他变量的不变式中

volatile只保证了可见性,所以Volatile适合直接赋值的场景,如

 

Java代码 复制代码  收藏代码
  1. public   class  VolatileTest{   
  2.    public   volatile   int  a;   
  3.    public   void  setA( int  a){   
  4.        this .a=a;   
  5.   }   
  6. }  

 

 


在没有volatile声明时,多线程环 境下,a的最终值不一定是正确的,因为this.a=a;涉及到给a赋值和将a同步回主存的步骤,这个顺序可能被打乱。如果用volatile声明了,读 取主存副本到工作内存和同步a到主存的步骤,相当于是一个原子操作。所以简单来说,volatile适合这种场景:一个变量被多个线程共享,线程直接给这个变量赋值。这是一种很简单的同步场景,这时候使用volatile的开销将会非常小。站内很多人都问我,所谓线程的“工作内存”到底是个什么东西?有的人认为是线程的栈,其实这种理解是不正确的。看看JLS(java语言规范)对线程工作内存的描述,线程的working memory只是cpu的寄存器和高速缓存的抽象描述。

 

      可能 很 多人都觉得莫名其妙,说JVM的内存模型,怎么会扯到cpu上去呢?在此,我认为很有必要阐述下,免得很多人看得不明不白的。先抛开java虚拟机不谈, 我们都知道,现在的计算机,cpu在计算的时候,并不总是从内存读取数据,它的数据读取顺序优先级是:寄存器-高速缓存-内存。线程耗费的是CPU,线程 计算的时候,原始的数据来自内存,在计算过程中,有些数据可能被频繁读取,这些数据被存储在寄存器和高速缓存中,当线程计算完后,这些缓存的数据在适当的 时候应该写回内存。当个多个线程同时读写某个内存数据时,就会产生多线程并发问题,涉及到三个特性:原子性,有序性,可见性。在《线程安全总结》这篇文章 中,为了理解方便,我把原子性和有序性统一叫做“多线程执行有序性”。支持多线程的平台都会面临这种问题,运行在多线程平台上支持多线程的语言应该提供解 决该问题的方案。

 

       那么,我们看看JVM,JVM是一个虚拟的计算机,它也会面临多线程并发问题,java程序运行在java虚拟机平台上,java程序员不可能直接去控制底层线程对寄存器高速缓存内存之间的同步,那么java从语法层面,应该给开发人员提供一种解决方案,这个方案就是诸如 synchronized, volatile,锁机制(如同步块,就绪队列,阻塞队列)等等。这些方案只是语法层面的,但我们要从本质上去理解它,不能仅仅知道一个 synchronized 可以保证同步就完了。   在这里我说的是jvm的内存模型,是动态的,面向多线程并发的,沿袭JSL的“working memory”的说法,只是不想牵扯到太多底层细节,因为 《线程安全总结》这篇文章意在说明怎样从语法层面去理解java的线程同步,知道各个关键字的使用场景。

 

      今 天有人问我,那java的线程不是有栈吗?难道栈不是工作内存吗?工作内存这四个字得放到具体的场景中描述,方能体现它具体的意义,在描述JVM的线程同 步时,工作内存指的是寄存器和告诉缓存的抽象描述,具体请自行参阅JLS。上面讲的都是动态的内存模型,甚至已经超越了JVM的范围,那么JVM的内存静 态存储是怎么划分的?今天还有人问我,jvm的内存模型不是有eden区吗?也不见你提起。我跟他说,这是两个角度去看的,甚至是两个不同的范围,动态的 线程同步的内存模型,涵盖了cpu,寄存器,高速缓存,内存;JVM的静态内存储模型只是一种对内存的物理划分而已,它只局限在内存,而且只局限在JVM 的内存。那些什么线程栈,eden区都仅仅在JVM内存。

 

      说说JVM的线程栈和有个朋友反复跟我纠结的eden区吧。JVM的内存,被划分了很多的区域:

1.程序计数器
每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令。
2.线程栈
线 程的每个方法被执行的时候,都会同时创建一个帧(Frame)用于存储本地变量表、操作栈、动态链接、方法出入口等信息。每一个方法的调用至完成,就意味 着一个帧在VM栈中的入栈至出栈的过程。如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果VM栈可以 动态扩展(VM Spec中允许固定长度的VM栈),当扩展时无法申请到足够内存则抛出OutOfMemoryError异常。
3.本地方法栈
4.堆

每 个线程的栈都是该线程私有的,堆则是所有线程共享的。当我们new一个对象时,该对象就被分配到了堆中。但是堆,并不是一个简单的概念,堆区又划分了很多 区域,为什么堆划分成这么多区域,这是为了JVM的内存垃圾收集,似乎越扯越远了,扯到垃圾收集了,现在的jvm的gc都是按代收集,堆区大致被分为三大 块:新生代,旧生代,持久代(虚拟的);新生代又分为eden区,s0区,s1区。新建一个对象时,基本小的对象,生命周期短的对象都会放在新生代的 eden区中,eden区满时,有一个小范围的gc(minor gc),整个新生代满时,会有一个大范围的gc(major gc),将新生代里的部分对象转到旧生代里。
5.方法区
其 实就是永久代(Permanent Generation),方法区中存放了每个Class的结构信息,包括常量池、字段描述、方法描述等等。VM Space描述中对这个区域的限制非常宽松,除了和Java堆一样不需要连续的内存,也可以选择固定大小或者可扩展外,甚至可以选择不实现垃圾收集。相对 来说,垃圾收集行为在这个区域是相对比较少发生的,但并不是某些描述那样永久代不会发生GC(至 少对当前主流的商业JVM实现来说是如此),这里的GC主要是对常量池的回收和对类的卸载,虽然回收的“成绩”一般也比较差强人意,尤其是类卸载,条件相 当苛刻。
6.常量池
 Class 文件中除了有类的版本、字段、方法、接口等描述等信息外,还有一项信息是常量表(constant_pool table),用于存放编译期已可知的常量,这部分内容将在类加载后进入方法区(永久代)存放。但是Java语言并不要求常量一定只有编译期预置入 Class的常量表的内容才能进入方法区常量池,运行期间也可将新内容放入常量池(最典型的String.intern()方法)。

 

关于垃圾收集,在此不多说,流到垃圾收集那一章再 详细说吧。关于java的同步,其实还有基于CPU原语的比较并交换的非阻塞算法(CAS),不过这个在java的并发包里已经实现了很多,因此关于这 点,就留到java并发包那一章介绍吧。后面我会专门写一篇文章,JVM内存与垃圾收集。

分享到:
评论

相关推荐

    浅谈Java内存模型之happens-before

    "浅谈Java内存模型之happens-before" Java内存模型是Java虚拟机中的一种机制,用于定义Java程序中线程之间的内存访问方式。在多线程环境下,线程之间的通信和数据共享是非常复杂的,需要有一些规则来保证数据的一致...

    浅谈Java内存区域划分和内存分配策略

    "浅谈Java内存区域划分和内存分配策略" 本文将详细讲述Java内存区域划分和内存分配策略,涵盖程序计数器、虚拟机栈、本地方法栈、堆、方法区等内存区域的概念和作用,以及对象创建过程和内存分配策略。 程序计数器...

    Java积累文档

    程序实现树形,J2EE_6.0_API.chm,JAVA6交口称赞3.0.chm,java编程思想(完整版).chm,Java解惑.pdf,Java日期处理.txt,JAVA设计模式.chm,JDK_API_1_6_zh_CN.CHM,浅谈java内存模型.txt

    浅谈Java内存区域与对象创建过程

    浅谈Java内存区域与对象创建过程 Java内存区域是Java虚拟机在执行Java程序的过程中所管理的内存,它被划分为若干个不同的数据区域,每个区域都有其自己的用途和创建和销毁的时间。根据《Java虚拟机规范(JavaSE7版...

    浅谈Java并发中的内存模型

    Java并发中的内存模型,即Java Memory Model (JMM),是Java平台为了确保多线程环境下的正确性而设计的一种抽象概念。JMM的目标是提供一个规范,使得在各种硬件和操作系统环境下,Java程序的内存访问行为保持一致,...

    浅谈android线程模型

    ### 浅谈Android线程模型:深入理解与实践 #### 引言 随着智能手机的普及和技术的不断进步,Google的Android操作系统成为了移动设备领域的重要力量。Android不仅为用户提供了丰富的功能,也为开发者提供了广阔的...

    浅谈Java的虚拟机结构以及虚拟机内存的优化

    总的来说,深入理解Java虚拟机的结构和内存模型,不仅可以提升代码的效率和稳定性,还能帮助我们编写出更符合JVM特性的高效代码。通过持续学习和实践,我们可以成为更好的Java开发者,创造出更加健壮、高效的软件...

    浅谈jvm原理

    "浅谈 JVM 原理" JVM(Java Virtual Machine)是一种虚拟机,它可以模拟完整的硬件系统功能,运行在一个完全隔离的环境中,提供了一个完整的计算机系统。JVM 可以分为三类:VMWare、Visual Box 和 JVM。其中,...

    浅谈java指令重排序的问题

    "浅谈java指令重排序的问题" Java指令重排序是Java虚拟机(JVM)和CPU的优化机制,目的是为了提高程序的执行效率。该机制可以在虚拟机层面和硬件层面对指令进行重新排序,以充分利用CPU的资源。 虚拟机层面的指令...

    浅谈计算机软件开发的JAVA编程语言.zip

    Java使用垃圾回收机制自动管理内存,减少了程序员处理内存泄漏的风险。此外,Java采用类作为基本的构造单元,支持多态性和封装,使得代码更加模块化和易于维护。 Java的跨平台能力得益于Java虚拟机(JVM)。JVM允许...

    浅谈Java 并发的底层实现

    总结一下,Java并发的底层实现涉及到操作系统级别的线程调度、Java内存模型(JMM)、volatile关键字的可见性保证以及无锁并发编程技术如原子类和CAS操作。理解这些概念和机制,对于编写高效、线程安全的Java并发程序...

    浅谈Java中BIO、NIO和AIO的区别和应用场景

    Java中IO模型有三种:BIO、NIO和AIO,下面我们来详细介绍它们的区别和应用场景。 BIO(Blocking I/O) BIO是Java中最古老的IO模型,它是同步并阻塞的。服务器的实现模式是一个连接一个线程,这样的模式很明显的一...

    浅谈Java中类的实例化步骤

    在Java编程语言中,类的实例化是一个关键概念,它涉及到如何创建对象并分配内存空间。今天我们将深入探讨Java中类的实例化步骤,特别是与`static`关键字相关的部分。 首先,`static`关键字在Java中有着特殊的意义,...

    digester(浅谈第一次使用)

    在“浅谈第一次使用”的描述中,可能涵盖了博主初次尝试使用Digester时的经验和遇到的问题,以及逐步理解和掌握该工具的过程。由于描述信息为空,我们无法获取具体的细节,但可以假设内容可能包括了基本概念介绍、...

    浅谈计算机应用软件开发中编程语言的选择研究中英文对照.pdf

    浅谈计算机应用软件开发中编程语言的选择研究 随着信息技术的飞速发展,计算机应用软件已经深入到我们生活的各个角落,成为现代社会不可或缺的一部分。对于软件开发企业来说,选择合适的编程语言至关重要,因为它...

    java gc调优

    在《浅谈JVM内存管理》的PPT中,可能包含了对上述概念的详细讲解,包括JVM内存模型的解析、GC算法的工作原理、如何配置和调整GC参数,以及通过实例分析GC调优的具体步骤。通过学习这个PPT,开发者可以深入理解JVM...

    浅谈关于Java的GC垃圾回收器的一些基本概念

    本文主要探讨Java GC的基本概念,涉及JVM内存模型以及不同的垃圾回收算法。 首先,让我们了解几种基本的垃圾回收算法: 1. **引用计数**:每个对象有一个引用计数,当引用增加时计数加1,引用减少时减1。当计数为0...

    浅谈C语言的前世今生.pdf

    Java则采用了虚拟机和字节码的技术,实现了跨平台的运行能力,并在语言层面取消了指针,引入垃圾回收机制来解决内存管理问题。 C语言之所以能够长久不衰,除了它的高效和稳定之外,它在低级编程和硬件操作方面提供...

    浅谈计算机操作系统中线程与超线程技术及应用.pdf

    Java的线程模型基于操作系统线程,Python则在早期版本中使用了全局解释器锁(GIL),限制了多线程在CPU密集型任务中的并行性,但在多线程I/O操作上仍能发挥优势。Python的后期版本和一些库如Jython、PyPy等,通过...

Global site tag (gtag.js) - Google Analytics