LWJGL lag while creating VBOs
===

I am making a game like Minecraft, where the player walks about in an infinite world. Before I implemented the infinite world, the game would only lag at the start, now it lags whenever I move the character and it has to compile 0-3 sets of 4 VBOs per new chunk/chunk with new chunk next to it.  Heres the code:

    for(int dofor = 0; dofor < rendering.size(); ++dofor){
			ChunkSP c = (ChunkSP) rendering.get(dofor);
			if(c.compileStage == 2){
				if(compiled > 4) continue; //Stops some lag, but not all
				if(c.rebuild){
					c.rebuild = false;
					c.switchOld(); //Make sure the player can see something while the chunk is rebuilding
				}
				else if(c.setupRenderer()) ++compiled; //Here is the cause of the lag
			} else if(c.compileStage == 0 && built < 30){
				c.compileStage = 1;
				ChunkBuildThread20.buildChunk(c); //Gather the Vertexes in another thread, so no lag
				++built;
			}
			if(c.rebuild && c.compileStage == 4){
					c.rebuild = false;
					c.switchOld();
			}
			c.renderSolids(); //Rendering when all VBOs are built causes no lag
			
			
		}

ChunkSP:

    public boolean setupRenderer(){
		if(compileStage == 0){
			addVertexsToList(); //Done on the thread
		}
		compileStage = 3;
		if(!isEmpty){
			if(hasVBO[0]){ //If the building determined we had solids
				renderers[0].compile3(); //Compile 1 and 2 can be done on the thread.
			}
			if(hasVBO[1]){ //If the building determined we had transparent objects
				renderers[1].compile3();
			}
			if(hasVBO[2]){ //If the building determined we had fluids
				renderers[2].compile3();
			}
			compileStage = 4; //Set the compile stage to 4, which means ready to render
			oldRs = null; //Dispose of the old renderers used to make sure the player saw something while it was rebuilding
			return true;
		}
		compileStage = 4;
		oldRs = null;
		return false; //Return false if the chunk is empty so another chunk can be built
	}

CustomVBORenderer:

    public void compile1(){ //Done on build thread
		canInput = false;
		amountOfVertexes = vertexes.size() / 3;
		if(amountOfVertexes < 1) return;
		
		tempVD = vertexes.toArray(); //These lists are a class called FloatList, which is a fast list of primative floats without boxing. tempVD is the temporary vertex data
		tempPCD = primaryColors.toArray();
		tempTCD = texCoords.toArray();
		tempCD = customs.toArray(); //Custom data sent to my vertex shaders for special effects such as waving grass
	}
	public void compile2(){ //Done on build thread
		if(amountOfVertexes < 1) return;
		
		vertexData = BufferUtils.createFloatBuffer(tempVD.length);
		vertexData.put(tempVD);
		primColorData = BufferUtils.createFloatBuffer(tempPCD.length);
		primColorData.put(tempPCD);
		texCoordData = BufferUtils.createFloatBuffer(tempTCD.length);
		texCoordData.put(tempTCD);
		customData = BufferUtils.createFloatBuffer(tempCD.length);
		customData.put(tempCD);
		vertexData.flip();
		primColorData.flip();
		texCoordData.flip();
		customData.flip();
	}
	public void compile3(){ //Done on render thread
		if(amountOfVertexes < 1) return;
		
		if(!builtOnce)vboVertexID = glGenBuffers(); //buildOnce determines whether to create new VBOs or use old ones
		glBindBuffer(GL_ARRAY_BUFFER, vboVertexID); //Build the VBOs
		glBufferData(GL_ARRAY_BUFFER, vertexData, DRAW_METHOD); //DRAW_METHOD is GL_STATIC_DRAW
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		if(!builtOnce)vboPrimColorID = glGenBuffers();
		glBindBuffer(GL_ARRAY_BUFFER, vboPrimColorID);
		glBufferData(GL_ARRAY_BUFFER, primColorData, DRAW_METHOD);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		if(!builtOnce)vboTexCoordID = glGenBuffers();
		glBindBuffer(GL_ARRAY_BUFFER, vboTexCoordID);
		glBufferData(GL_ARRAY_BUFFER, texCoordData, DRAW_METHOD);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		if(!builtOnce) vboCustomID = glGenBuffers();
		glBindBuffer(GL_ARRAY_BUFFER, vboCustomID);
		glBufferData(GL_ARRAY_BUFFER, customData, DRAW_METHOD);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		builtOnce = true;
		
		vertexes = null; //Cleaning up after build to stop these taking up large amounts of memory
		primaryColors = null;
		texCoords = null;
		customs = null;
		tempVD = null;
		tempPCD = null;
		tempTCD = null;
		tempCD = null;
		vertexData = null;
		primColorData = null;
		texCoordData = null;
		customData = null;
	}
    public void render() {
		
		if(amountOfVertexes < 1) return;
		if(vboVertexID == 0) return;
		
		boolean normalized = true;
		glBindBuffer(GL_ARRAY_BUFFER, vboVertexID);
		glVertexAttribPointer(0, 3, GL_FLOAT, normalized, 0, 0L);
		
		glBindBuffer(GL_ARRAY_BUFFER, vboPrimColorID);
		glVertexAttribPointer(3, 4, GL_FLOAT, normalized, 0, 0L);
		
		glBindBuffer(GL_ARRAY_BUFFER, vboTexCoordID);
		glVertexAttribPointer(8, 3, GL_FLOAT, normalized, 0, 0L);
		
		glBindBuffer(GL_ARRAY_BUFFER, vboCustomID);
		glVertexAttribPointer(customIndex, 4, GL_FLOAT, normalized, 0, 0L);
		
		glDrawArrays(GL_QUADS, 0, amountOfVertexes); //Is there a faster way with glMultiDrawArrays?
		
		glBindBuffer(GL_ARRAY_BUFFER, 0);
	}
	public static void prepareForRendering(Object...objects){
		if(objects.length > 0){
			glEnable(GL_TEXTURE_2D); //Enable and bind textures from the passed in objects
			glBindTexture(GL_TEXTURE_2D, (Integer)objects[0]);
			
			ted = true;
		} else {
			glDisable(GL_TEXTURE_2D);
		}
		
		//glEnable(GL_COLOR_SUM);
		
		glEnableVertexAttribArray(0); //Vertexes
		glEnableVertexAttribArray(3); //Colors
		glEnableVertexAttribArray(8); //glMultiTexCoord0
		glEnableVertexAttribArray(customIndex); //Custom data for special effects
	}
	public static void finishRendering(){
		
		glDisableVertexAttribArray(0);
		glDisableVertexAttribArray(3);
		glDisableVertexAttribArray(8);
		glDisableVertexAttribArray(customIndex);
		
		if(ted){
			glDisable(GL_TEXTURE_2D); //Texture disabling
			ted = false;
		}
		
		
	}

Is there any way I can optimise the code above to stop lag while the player is moving?