import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestInterface {

	private static final int buffSize = 100000;
	static enum TestKind {NATIVE,INTERFACE,CAST}

	private int nativeTest(long count) {
		StringBuilder builder = new StringBuilder();
		for (long i=0;i<count;i++) {
			if (builder.length()>=buffSize)
				builder = new StringBuilder();
			builder.append("a");
		}
		return builder.length();
	}

	private int interfaceTest(long count) {
		StringBuilder builder = new StringBuilder();
		CharSequence sequence = builder;
		for (long i=0;i<count;i++) {
			if (sequence.length()>=buffSize) {
				builder = new StringBuilder();
				sequence = builder;
			}
			builder.append("a");
		}
		return sequence.length();
	}

	private Object createBuilder() {
		return new StringBuilder(); 
	}
	private int castTest(long count) {
		Object test = createBuilder();
		for (long i=0;i<count;i++) {
			if (((CharSequence)test).length()>=buffSize) {
				test = createBuilder();
			}
			((StringBuilder)test).append("a");
		}
		return ((CharSequence)test).length();
	}

	public void test(long count, TestKind testKind) {
		long startTime = System.currentTimeMillis();
		switch (testKind) {
		case NATIVE:nativeTest(count);break;
		case INTERFACE:interfaceTest(count);
		case CAST:castTest(count);
		}
		long finalTime = System.currentTimeMillis();
		System.out.println("testKind:"+testKind+" time:"+(finalTime-startTime));
	}

	private static class RunnableTest implements Runnable {
		@Override
		public void run() {
			TestInterface test = new TestInterface();
			long count = 100000000;
			test.test(count,TestKind.NATIVE);
			test.test(count,TestKind.INTERFACE);
			test.test(count,TestKind.CAST);
		}
	}

	public static void main(String[] args) {
		System.out.println("************* warmUp *******************");
		new RunnableTest().run();
		System.out.println("************* warmUp end ***************");
		//new RunnableTest().run();

		int threadCount = 5;
		ExecutorService s = Executors.newFixedThreadPool(threadCount);
		for (int i=0;i<threadCount;i++) {
			s.execute(new RunnableTest());
		}
	}
}