java线程安全总结

时间  2019-11-19
标签 java 线程 安全 总结 栏目 Java 繁體版
原文   原文链接

原文：   java

http://www.iteye.com/topic/806990程序员

http://www.iteye.com/topic/808550算法

  

      最近想将Java基础的一些东西都整理整理，写下来，这是对知识的总结，也是一种乐趣。已经拟好了提纲，大概分为这几个主题： java线程安全，java垃圾收集，java并发包详细介绍，java profile和jvm性能调优 。慢慢写吧。本人jameswxx原创文章，转载请注明出处，我费了不少心血，多谢了。关于java线程安全，网上有不少资料，我只想从本身的角度总结对这方面的考虑，有时候写东西是很痛苦的，知道一些东西，但想用文字说清楚，却不是那么容易。我认为要认识java线程安全，必须了解两个主要的点：java的内存模型，java的线程同步机制。特别是内存模型，java的线程同步机制很大程度上都是基于内存模型而设定的。后面我还会写java并发包的文章，详细总结如何利用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++;  

 for(int i=0;i<10;i++)并发

  a++;jvm

 


线程有可能只对工做内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，因此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. }  

public class Account {

 

    private int balance;

 

    public Account(int balance) {

        this.balance = balance;

    }

 

    public int getBalance() {

        return balance;

    }

 

    public void add(int num) {

        balance = balance + num;

    }

 

    public void withdraw(int num) {

        balance = balance - num;

    }

 

    public static void main(String[] args) throws InterruptedException {

        Account account = new Account(1000);

        Thread a = new Thread(new AddThread(account, 20), "add");

        Thread b = new Thread(new WithdrawThread(account, 20), "withdraw");

        a.start();

        b.start();

        a.join();

        b.join();

        System.out.println(account.getBalance());

    }

 

    static class AddThread implements Runnable {

        Account account;

        int     amount;

 

        public AddThread(Account account, int amount) {

            this.account = account;

            this.amount = amount;

        }

 

        public void run() {

            for (int i = 0; i < 200000; i++) {

                account.add(amount);

            }

        }

    }

 

    static class WithdrawThread implements Runnable {

        Account account;

        int     amount;

 

        public WithdrawThread(Account account, int amount) {

            this.account = account;

            this.amount = amount;

        }

 

        public void run() {

            for (int i = 0; i < 100000; i++) {

                account.withdraw(amount);

            }

        }

    }

}

 


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

 


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

Java代码  

  1. synchronized(锁){   
  2.      临界区代码   
  3. }   

synchronized(锁){

     临界区代码

}

 


为了保证银行帐户的安全，能够操做帐户的方法以下：

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. }  

public synchronized void add(int num) {

     balance = balance + num;

}

public synchronized void withdraw(int num) {

     balance = balance - num;

}

 


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

Java代码  

  1. synchronized(锁){   
  2. 临界区代码   
  3. }  

synchronized(锁){

临界区代码

}

 


那么对于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. }  

public class ThreadTest{

  public void test(){

     Object lock=new Object();

     synchronized (lock){

        //do something

     }

  }

}

 


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. }  

Object lock=new Object();//声明了一个对象做为锁

   synchronized (lock) {

       balance = balance - num;

       //这里放弃了同步锁，好不容易获得，又放弃了

       lock.wait();

}

 


若是一个线程得到了锁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.         while(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.         while(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. }  

import java.util.ArrayList;

import java.util.List;

 

public class Plate {

 

    List<Object> eggs = new ArrayList<Object>();

 

    public synchronized Object getEgg() {

        while(eggs.size() == 0) {

            try {

                wait();

            } catch (InterruptedException e) {

            }

        }

 

        Object egg = eggs.get(0);

        eggs.clear();// 清空盘子

        notify();// 唤醒阻塞队列的某线程到就绪队列

        System.out.println("拿到鸡蛋");

        return egg;

    }

 

    public synchronized void putEgg(Object egg) {

        while(eggs.size() > 0) {

            try {

                wait();

            } catch (InterruptedException e) {

            }

        }

        eggs.add(egg);// 往盘子里放鸡蛋

        notify();// 唤醒阻塞队列的某线程到就绪队列

        System.out.println("放入鸡蛋");

    }

   

    static class AddThread extends Thread{

        private Plate plate;

        private Object egg=new Object();

        public AddThread(Plate plate){

            this.plate=plate;

        }

       

        public void run(){

            for(int i=0;i<5;i++){

                plate.putEgg(egg);

            }

        }

    }

   

    static class GetThread extends Thread{

        private Plate plate;

        public GetThread(Plate plate){

            this.plate=plate;

        }

       

        public void run(){

            for(int i=0;i<5;i++){

                plate.getEgg();

            }

        }

    }

   

    public static void main(String args[]){

        try {

            Plate plate=new Plate();

            Thread add=new Thread(new AddThread(plate));

            Thread get=new Thread(new GetThread(plate));

            add.start();

            get.start();

            add.join();

            get.join();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("测试结束");

    }

}

  执行结果：

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. }  

public class VolatileTest{

  public volatile int a;

  public void add(int count){

       a=a+count;

  }

}

 


        当一个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. }  

public class VolatileTest{

  public volatile int a;

  public void setA(int a){

      this.a=a;

  }

}

 


在没有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内存与垃圾收集。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程