64位Windows10中每个java进程的最大内存量？

Question

我正在使用带有8GB内存的64位windows10操作系统。我的eclipse.ini文件如下：

-startup 
plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar 
--launcher.library 
plugins/org.eclipse.equinox.launcher.win32.win32.x86_64_1.1.300.v20150602-1417 
-product 
org.eclipse.epp.package.jee.product 
--launcher.defaultAction 
openFile 
--launcher. 
-XX:MaxPermSize 
-Xms4000m 
-Xmx8000m 
-showsplash 
org.eclipse.platform 
--launcher.XXMaxPermSize 
-Xms4000m 
-Xmx8000m 
--launcher.defaultAction 
openFile 
-vm C:\Program Files\Java\jre1.8.0_91\bin\javaw.exe 
--launcher.appendVmargs 
-vmargs 
-Dosgi.requiredJavaVersion=1.7 
-Xms4000m 
-Xmx8000m 

我只是试图在二进制搜索树中插入100000值。当我尝试在BST中输入10000个值时，我的代码工作正常，但是当我试图在BST中插入100000个值时，我正面临JVM堆大小问题。我也做了以下步骤 - 去跑配置 - 转到参数 - 在VM参数部分 - 我已经加入-Xms4000m -Xmx8000m

我的代码如下：

public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> 
{ 
/** 
    * Construct the tree. 
    */ 
public BinarySearchTree() 
{ 
    root = null; 
} 

/** 
    * Insert into the tree; duplicates are ignored. 
    * @param x the item to insert. 
    */ 
public void insert(AnyType x) 
{ 
    root = insert(x, root); 
} 

/** 
    * Remove from the tree. Nothing is done if x is not found. 
    * @param x the item to remove. 
    */ 
public void remove(AnyType x) 
{ 
    root = remove(x, root); 
} 

/** 
    * Find the smallest item in the tree. 
    * @return smallest item or null if empty. 
    */ 
public AnyType findMin() 
{ 
    if(isEmpty()) 
     return null; 
    return findMin(root).element; 
} 

/** 
    * Find the largest item in the tree. 
    * @return the largest item of null if empty. 
    */ 
public AnyType findMax() 
{ 
    if(isEmpty()) 
     return null; 
    return findMax(root).element; 
} 

/** 
    * Find an item in the tree. 
    * @param x the item to search for. 
    * @return true if not found. 
    */ 
public boolean contains(AnyType x) 
{ 
    return contains(x, root); 
} 

/** 
    * Make the tree logically empty. 
    */ 
public void makeEmpty() 
{ 
    root = null; 
} 

/** 
    * Test if the tree is logically empty. 
    * @return true if empty, false otherwise. 
    */ 
public boolean isEmpty() 
{ 
    return root == null; 
} 

/** 
    * Print the tree contents in sorted order. 
    */ 
public void printTree() 
{ 
    if(isEmpty()) 
     System.out.println("Empty tree"); 
    else 
     printTree(root); 
} 

/** 
    * Internal method to insert into a subtree. 
    * @param x the item to insert. 
    * @param t the node that roots the subtree. 
    * @return the new root of the subtree. 
*/ 
private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return new BinaryNode<>(x, null, null); 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     t.left = insert(x, t.left); 
    else if(compareResult > 0) 
     t.right = insert(x, t.right); 
    else 
     ; // Duplicate; do nothing 
    return t; 
} 

/** 
    * Non recursive method, created by LR - 29-092014 

private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return new BinaryNode<>(x, null, null); 

    while (t != null) {  
     int compareResult = x.compareTo(t.element); 

     if(compareResult < 0) 
      t = t.left; 
     else if(compareResult > 0) 
      t = t.right; 
     else 
      ; // Duplicate; do nothing 
    } 
     return t; 
}*/ 

/** 
    * Internal method to remove from a subtree. 
    * @param x the item to remove. 
    * @param t the node that roots the subtree. 
    * @return the new root of the subtree. 
    */ 
private BinaryNode<AnyType> remove(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return t; // Item not found; do nothing 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     t.left = remove(x, t.left); 
    else if(compareResult > 0) 
     t.right = remove(x, t.right); 
    else if(t.left != null && t.right != null) // Two children 
    { 
     t.element = findMin(t.right).element; 
     t.right = remove(t.element, t.right); 
    } 
    else 
     t = (t.left != null) ? t.left : t.right; 
    return t; 
} 

/** 
    * Internal method to find the smallest item in a subtree. 
    * @param t the node that roots the subtree. 
    * @return node containing the smallest item. 
    */ 
private BinaryNode<AnyType> findMin(BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return null; 
    else if(t.left == null) 
     return t; 
    return findMin(t.left); 
} 

/** 
    * Internal method to find the largest item in a subtree. 
    * @param t the node that roots the subtree. 
    * @return node containing the largest item. 
    */ 
private BinaryNode<AnyType> findMax(BinaryNode<AnyType> t) 
{ 
    if(t != null) 
     while(t.right != null) 
      t = t.right; 

    return t; 
} 

/** 
    * Internal method to find an item in a subtree. 
    * @param x is item to search for. 
    * @param t the node that roots the subtree. 
    * @return node containing the matched item. 
    */ 
private boolean contains(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return false; 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     return contains(x, t.left); 
    else if(compareResult > 0) 
     return contains(x, t.right); 
    else 
     return true; // Match 
} 

/** 
    * Internal method to print a subtree in sorted order. 
    * @param t the node that roots the subtree. 
    */ 
private void printTree(BinaryNode<AnyType> t) 
{ 
    if(t != null) 
    { 
     printTree(t.left); 
     System.out.println(t.element); 
     printTree(t.right); 
    } 
} 

/** 
    * Internal method to compute height of a subtree. 
    * @param t the node that roots the subtree. 
    */ 
private int height(BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return -1; 
    else 
     return 1 + Math.max(height(t.left), height(t.right));  
} 

// Basic node stored in unbalanced binary search trees 
private static class BinaryNode<AnyType> 
{ 
     // Constructors 
    BinaryNode(AnyType theElement) 
    { 
     this(theElement, null, null); 
    } 

    BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType> rt) 
    { 
     element = theElement; 
     left  = lt; 
     right = rt; 
    } 

    AnyType element;   // The data in the node 
    BinaryNode<AnyType> left; // Left child 
    BinaryNode<AnyType> right; // Right child 
} 


    /** The tree root. */ 
private BinaryNode<AnyType> root; 


} 

而且这里是我的main（）

public static void main(String [ ] args) 
{ 
    BinarySearchTree<Integer> t = new BinarySearchTree<>(); 
    final int NUMS = 100000; // must be even 
    for(int i = 1; i <= NUMS; i++) 
    { 
     t.insert(i); 
    } 

} 

和我得到以下异常

Exception in thread "main" java.lang.StackOverflowError 

在下面的方法，特别在粗线

private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return new BinaryNode<>(x, null, null); 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     t.left = insert(x, t.left); 
    else if(compareResult > 0) 
     **t.right = insert(x, t.right);** 
    else 
     ; // Duplicate; do nothing 
    return t; 
} 

但不幸的是我得到同样的错误。有人请让我知道代码，配置或eclipse.ini文件有什么问题。

Answer 1

StackOverflowError表示您的方法递归太深。它表明你需要深度递归，例如10k +深度，或者你有一个bug。

用完OutOfMemoryError即可考虑修复堆大小或修复程序以减少堆。

在这种情况下，对于平衡树，深度应该在O（log2（n））左右，但树不平衡。

即你的树是这个样子

1 \ 
    2 \ 
    3 \ 
     4 \ 
     5 \ 
      6 \ always more to the right. 

有效它已经变成了一个链接列表，并在列表中元素的个数是深度堆栈需要去增加一个元素。

您可以通过程序（而不是eclipse）上的-Xss来增加堆栈深度，但是如果您的计划是实现树而不是链接列表，我建议您使它成为一个平衡树（或者避免使用递归作为LinkedList ）