static void insertSort1(int []sorts) {
    for(int i = 1;i<sorts.length;i++) {
        int tmp = sorts[i];//哨兵
        int j= i-1;
        while(j >=0 && tmp < sorts[j]) {
            sorts[j+1] = sorts[j];//比tmp大的全部往右移动
            j--;
        }
        //别的移完位置，把哨兵放到正确的位置
        sorts[++j] = tmp;
    }
}

/**
 * 分治法,从小到大排序
 * @param array
 */
public static int partition(int []array,int start,int end) {

    //取一位做为基数
    int pivot = array[end];//这儿取最后一位作为基数了

    int left = start;
    int right = end-1;//从倒数第二位开始比较

    //从两头向中间搜索,从小到大排序
    while (left < right) {
        //从left端开始搜索
        while(left < right && array[left] <= pivot) {
            left ++;
        }
        //从right端开始搜索
        while (left < right && array[right] >= pivot) {
            right -- ;
        }
        //两数交换,大的放到右边，小的放到左边
        if(left < right) {
            swap(array,left,right);
            left++;
            right--;
        }
    }
    //
    if(left != end && array[left] > array[end] ) {
        swap(array,left,end);
        return left;
    }
    //right == left
    return left+1;
}

/**
 * 分治法,从小到大排序
 * @param array
 * @param start
 * @param end
 */
private static void quicSort(int []array,int start,int end){
    if( start < end ){
        int partition = partition(array,start,end);
        print(array);
        quicSort(array,start,partition-1);
        quicSort(array,partition+1,end);
    }
}

int partion(int arr[], int begin, int end)
{
    int pit = arr[end];//挖最右数，留一个坑
    int left = begin;
    int right = end;

    while (left < right)
    {
        //从最左开始搜索比坑大的数
        while (left < right && arr[left] <= pit)
            left++;
        if (left<right) {
            arr[right] = arr[left];//拿left去填坑，left成为新坑
        }
        while (left < right && arr[right] >= pit)
            right--;
        if (left < right) {
            arr[left] = arr[right];//right去填left坑，left成为新坑
        }
    }

    arr[left] = pit;//用key填坑
    return left;
}

void QuickSort(int arr[], int left, int right)
{
    if (left < right)
    {
        int mid = partion(arr, left, right);
        print(arr);
        QuickSort(arr, left, mid - 1);
        QuickSort(arr, mid + 1, right);
    }
}

int partion(int arr[], int left, int right)
{
    int key = arr[right];//取最后一位为key

    int cur = left;//当前指针
    int prev = left - 1;//前一个指针

    while (cur < right)
    {
        if(arr[cur] < key && ++prev != cur){//发现比key小的数
            swap(arr,cur,prev);
        }
        cur++;
    }
    //最后++prev交换
    swap(arr,++prev,cur);
    return prev;
}

void QuickSort(int arr[], int left, int right)
{
    if (left < right)
    {
        int mid = partion(arr, left, right);
        print(arr);
        QuickSort(arr, left, mid - 1);
        QuickSort(arr, mid + 1, right);
    }
}

/**
 * 传统写法
 * @param sorts
 */
private static void bubbleSort(int [] sorts){
    for (int i=0;i<sorts.length-1;i++) {
        for (int j= 0;j<sorts.length-1-i;j++) {
            if(sorts[j] < sorts[j+1]) {
                swap(sorts,j,j+1);
            }
        }
    }
}

private static void swap(int []sorts,int i,int j){
        int tmp = sorts[i];
        sorts[i] = sorts[j];
        sorts[j] = tmp;
    }

/**
 * 如果部分已经排序,设置一个flag,有序就跳出循环
 * @param sorts
 */
private static void bubbleSort1(int [] sorts){
    for (int i=0;i<sorts.length-1;i++) {
        boolean flag = false;
        for (int j= 0;j<sorts.length-1-i;j++) {
            if(sorts[j] < sorts[j+1]) {
                swap(sorts,j,j+1);
                flag = true;
            }
        }
        if(!flag) {
            break;
        }
    }
}

/**
 * 鸡尾酒排序，定向冒泡排序
 * @param sorts
 */
private static void bubbleSort2(int [] sorts){
    int i = 0;
    int j = sorts.length-1;
    while (i <= j) {
        for(int s = i;s<j;s++) {//从左往右
            if(sorts[s] < sorts[s+1]) {
                swap(sorts, s, s + 1);
            }
        }

        System.out.println(JSON.toJSONString(sorts));
        for(int e = j;e>i;e--) {//从右往左
            if(sorts[e] > sorts[e-1]) {
                swap(sorts, e, e - 1);
            }
        }
        j--;i++;
        System.out.println(JSON.toJSONString(sorts));
    }
}

/**
 * 异步取得channel
 * @param index
 * @param callback
 */
public void asynGetChannel(int index,final Callback callback) {
    // 1. 随机获取一条channel
    final int pos = ThreadLocalRandom.current().nextInt(MAX_CONNECTIONS);
    Channel target = channels[pos];

    // 2. 如果获取到了连接，直接返回
    if (target != null && target.isActive()) {
        logger.info("direct success "+index);
        callback.onSuccess(target);
        return;
    }

    synchronized (locks[pos]) {
        target = channels[pos];
        // 2. 如果获取到了连接，直接返回
        if (target != null && target.isActive()) {
            callback.onSuccess(target);
            return;
        }

        // 3.如果连接正在创建中，则加入queue
        if (target instanceof EmptyChannel) {
            boolean result = jobs.offer(callback);
            if (result) {
                return;
            } else {
                throw new RuntimeException("Can't connet to target server and the waiting queue is full");
            }
        }

        // 4. 连接尚未创建
        channels[pos] = new EmptyChannel();

       Connector.connect(host, port, new Callback() {
           @Override
           public void onSuccess(Channel channel) {
               logger.info(index + " ------------connect success---------"+pos + " channel:" +channels[pos].getClass().getName());
               List<Callback> tmpJobs;//建立一个tempJobs，快速释放锁
               synchronized (locks[pos]) {
                   // 设置channels，拷贝jobs队列，释放锁
                   channels[pos] = channel;
                   tmpJobs = drainJobs();
               }
               for(Callback pendingCallback : tmpJobs) {
                   try {
                       if(pendingCallback != callback) {
                           pendingCallback.onSuccess(channel);
                       }
                   } catch (Exception e) {
                       logger.error("call connectionCallback fail", e);
                   }
               }
           }

           @Override
           public void onError(Throwable e) {
               List<Callback> tmpJobs;//建立一个tempJobs，快速释放锁
               synchronized (locks[pos]) {
                   // 设置channels，拷贝jobs队列，释放锁
                   channels[pos] = null;
                   tmpJobs = drainJobs();
               }
               for(Callback pendingCallback : tmpJobs) {
                   try {
                       if(pendingCallback != callback) {
                           pendingCallback.onError(e);
                       }
                   } catch (Exception x) {
                       logger.error("call connectionCallback fail", x);
                   }
               }
           }
       });
    }
}

Future future = doTask1();
doTask2();
doTask3();
Result result = future.get();

T(n) = O(f(n))

规律       Big-O

2             O(1)   --> 就是一个常数

2n + 10       O(n)   --> n 对整体结果会产生最大影响

5n^2         O(n^2) --> n^2 具有最大影响

bool IsFirstElementNull(IList<string> elements)
{
    return elements[0] == null;
}

bool ContainsValue(IList<string> elements, string value)
{
    foreach (var element in elements)
    {
        if (element == value) return true;
    }

    return false;
}

for (var outer = 0; outer < elements.Count; outer++)
    {
        for (var inner = 0; inner < elements.Count; inner++)
        {
            // Don't compare with self
            if (outer == inner) continue;

            if (elements[outer] == elements[inner]) return true;
        }
    }

int Fibonacci(int number)
{
    if (number <= 1) return number;

    return Fibonacci(number - 2) + Fibonacci(number - 1);
}

i=1;       
while (i<=n)
    i=i*2;

O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)

a)、要保证部署在tomcat上的每个应用依赖的类库相互独立，不受影响。
b)、由于tomcat是采用java语言编写的，它自身也有类库依赖，为了安全考虑，tomcat使用的类库要与部署的应用的类库相互独立。
c)、有些类库tomcat与部署的应用可以共享，比如说servlet-api，使用maven编写web程序时，servlet-api的范围是provided，
表示打包时不打包这个依赖，因为我们都知道服务器已经有这个依赖了。
d)、部署的应用之间的类库可以共享。这听起来好像与第一点相互矛盾，但其实这很合理，类被类加载器加载到虚拟机后，
会生成代表该类的class对象存放在永久代区域，这时候如果有大量的应用使用spring来管理，如果spring类库不能共享，
那每个应用的spring类库都会被加载一次，将会是很大的资源浪费。

/**
 * 类加载时间性能测试
 *
 * 看一下类加载需要消耗的时间
 * Created by Jack on 2018/10/8.
 */
public class ClassLoaderTest1 {
    public static void main(String[] args) throws SQLException {
        long s = System.nanoTime();

        LoaderClass loaderClass = new LoaderClass();
        long e = System.nanoTime();
        //第一次时间
        System.out.println(e - s);
        e = System.nanoTime();
        //第二次实例，但已经加载过，不再需要加载
        LoaderClass loaderClass1 = new LoaderClass();
        long e1 = System.nanoTime();
        //第二次时间
        System.out.println(e1 - e);
    }
}
//输出
2409737
396

Class<?> loadClass = platformClassLoader.loadClass("com.jack.Start");
Method startMethod = loadClass.getMethod("startUp");
startMethod.invoke(loadClass);

ClassLoader currentThreadLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(appClassLoader);

Class<?> contextClass = appClassLoader
				.loadClass("org.springframework.context.support.FileSystemXmlApplicationContext");
Class<?>[] parameterTypes = new Class[] { String[].class };
Constructor<?> constructor = contextClass.getConstructor(parameterTypes);
return constructor.newInstance(new Object[] { xmlPaths.toArray(new String[0]) });


// switch back the thread context classloader
Thread.currentThread().setContextClassLoader(currentThreadLoader);

ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); 
try{    
    Thread.currentThread().setContextClassLoader(targetTccl);    
    excute(); 
} finally { 
    Thread.currentThread().setContextClassLoader(classLoader); 
}

Class.forName("com.mysql.jdbc.Driver")
String url = "jdbc:mysql://localhost:3306/testdb";    
// 通过java库获取数据库连接
Connection conn = java.sql.DriverManager.getConnection(url, "name", "password");

callerCL = Thread.currentThread().getContextClassLoader();

callerC = Class.forName(driverClassName, true, callerClassLoader);

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
			throw new IllegalStateException(
					"Cannot initialize context because there is already a root application context present - " +
					"check whether you have multiple ContextLoader* definitions in your web.xml!");
		}

		Log logger = LogFactory.getLog(ContextLoader.class);
		servletContext.log("Initializing Spring root WebApplicationContext");
		if (logger.isInfoEnabled()) {
			logger.info("Root WebApplicationContext: initialization started");
		}
		long startTime = System.currentTimeMillis();

		try {
			// Determine parent for root web application context, if any.
			ApplicationContext parent = loadParentContext(servletContext);

			// Store context in local instance variable, to guarantee that
			// it is available on ServletContext shutdown.
			this.context = createWebApplicationContext(servletContext, parent);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
			if (ccl == ContextLoader.class.getClassLoader()) {
				currentContext = this.context;
			}
			else if (ccl != null) {
				currentContextPerThread.put(ccl, this.context);
			}

			if (logger.isDebugEnabled()) {
				logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
						WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
			}
			if (logger.isInfoEnabled()) {
				long elapsedTime = System.currentTimeMillis() - startTime;
				logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
			}

			return this.context;
		}
		catch (RuntimeException ex) {
			logger.error("Context initialization failed", ex);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
			throw ex;
		}
		catch (Error err) {
			logger.error("Context initialization failed", err);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
			throw err;
		}
	}

// 获取线程上下文类加载器，默认为WebAppClassLoader
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
// 如果spring的jar包放在每个webapp自己的目录中
// 此时线程上下文类加载器会与本类的类加载器（加载spring的）相同，都是WebAppClassLoader
if (ccl == ContextLoader.class.getClassLoader()) {
    currentContext = this.context;
}
else if (ccl != null) {
    // 如果不同，也就是上面说的那个问题的情况，那么用一个map把刚才创建的WebApplicationContext及对应的WebAppClassLoader存下来
    // 一个webapp对应一个记录，后续调用时直接根据WebAppClassLoader来取出
    currentContextPerThread.put(ccl, this.context);
}

public static WebApplicationContext getCurrentWebApplicationContext() {
		ClassLoader ccl = Thread.currentThread().getContextClassLoader();
		if (ccl != null) {
			WebApplicationContext ccpt = currentContextPerThread.get(ccl);
			if (ccpt != null) {
				return ccpt;
			}
		}
		return currentContext;
	}

/**
 * 主动 被动使用问题测试
 * Created by Jack on 2018/9/28.
 */
public class ClassInitTest3 {
    public static void main(String[] args) {
        String x = F.s;
    }
}

class F {
    //因为UUID.randomUUID().toString()这个方法，是运行期确认的，所以，这不是被动使用
    static final String s = UUID.randomUUID().toString();

    static {
        //这儿会被输出
        System.out.println("Initialize class F");
    }
}

/**
 * <clinit> 与 <init> 区别
 */
public class ClassInitTest2 {
    static {
        System.out.println("cinit");

        i = 3;//可以赋值
        //System.out.println(i);//但不能使用，语法错误
    }

    private static int i = 1;

    {
        System.out.println("init");//实例化构造器，
    }

    public static void main(String [] args)	{
        new ClassInitTest2();
        new ClassInitTest2();
        String str = "str";
        System.out.println(str);
    }
}

// 输出
cinit
init
init
str

/**
 * static 与 static final 对初始化的区别
 */
public class ClassInitFinalTest {
    public static  int age = 20;

    static {
        //如果age定义为static final，这儿就不会执行
        System.out.println("静态初始化！");
    }

    public static void main(String args[]){
        System.out.println(ClassInitFinalTest.age);
    }
}

/**
 * 测试类加载及初始化顺序问题
 * Created by jack01.zhu on 2018/9/28.
 */
public class ClassInit {
        private static ClassInit singleton = new ClassInit();
        public static int counter1;
        public static int counter2 = 0;
        private ClassInit() {
            counter1++;
            counter2++;
        }
        public static ClassInit getSingleton() {
            return singleton;
        }
}

/**
 * 通过输出结果，推测类加载过程
 * Created by jack01.zhu on 2018/9/28.
 */
public class ClassInitTestMain {

    public static void main(String []args) {
        ClassInit classInitTest = ClassInit.getSingleton();
        System.out.println("counter1="+classInitTest.counter1);
        System.out.println("counter2="+classInitTest.counter2);
    }
}

counter1=1
counter2=0

javac –verbose查看运行类是加载了jar文件

protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{

	// 首先检查，jvm中是否已经加载了对应名称的类，findLoadedClass(String )方法实际上是findLoadedClass0方法的wrapped方法，做了检查类名的工
       //作，而findLoadedClass0则是一个native方法，通过底层来查看jvm中的对象。
	Class c = findLoadedClass(name);
	if (c == null) {//类还未加载
	    try {
		if (parent != null) {
            //在类还未加载的情况下，我们首先应该将加载工作交由父classloader来处理。
		    c = parent.loadClass(name, false);
		} else {
                    //返回一个由bootstrap class loader加载的类，如果不存在就返回null
		    c = findBootstrapClassOrNull(name);
		}
	    } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found

                // from the non-null parent class loader
            }

            if (c == null) {
	        // If still not found, then invoke findClass in order
	        // to find the class.
	        c = findClass(name);//这里是我们的入手点，也就是指定我们自己的类加载实现
	    }
	}
	if (resolve) {
	    resolveClass(c);//用来做类链接操作
	}
	return c;
    }

public class LoaderClass {

    public void loader(){
        System.out.println("LoaderClass:"+this.getClass().getClassLoader());
        LoaderClass1 class1 = new LoaderClass1();
        class1.loader();
    }
}

public class LoaderClass1 {

    public void loader() {
        System.out.println(this.getClass().getName() + " loader:"+this.getClass().getClassLoader());

    }
}

public class MyClassLoader extends ClassLoader {

    protected Class<?> findClass(String name) throws ClassNotFoundException {

        String root = "d:/";

        byte[] bytes = null;
        try {
            //路径改到根目录下
            String file = root + name.substring(name.lastIndexOf(".")+1) + ".class";
            InputStream ins = new FileInputStream(file);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int length = 0;
            while ((length = ins.read(buffer)) != -1) {
                baos.write(buffer, 0, length);
            }
            bytes = baos.toByteArray();

            ins.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return defineClass(name, bytes, 0, bytes.length);
    }
}

public class ClassLoaderTest {

    public static void main(String[]args) throws Exception {
        ClassLoaderTest test = new ClassLoaderTest();

        System.out.println(test.getClass().getClassLoader());//输出sun.misc.Launcher$AppClassLoader

        System.out.println(test.getClass().getClassLoader().getParent());//输出sun.misc.Launcher$ExtClassLoader

        System.out.println(test.getClass().getClassLoader().getParent().getParent());//输出null

        //=====测试重复加载，类路径中LoaderClass.class存在=================
        //======虽然指定了classloader，但依然输出的是LoaderClass:sun.misc.Launcher$AppClassLoader
        //==删除类路径下的LoaderClass.class,才会输出LoaderClass:com.jack.classloader.MyClassLoader
        //并且loaderclass中创建的对象类加载器也是MyClassLoader
        MyClassLoader classLoader = new MyClassLoader();
        Class<?> loadClass = Class.forName("com.jack.classloader.LoaderClass", true, classLoader);
        Method startMethod = loadClass.getMethod("loader");
        startMethod.invoke(loadClass.newInstance());

        //===当类加载器不一样时，两个class不相等
        MyClassLoader classLoader1 = new MyClassLoader();
        Class<?> loadClass1 = Class.forName("com.jack.classloader.LoaderClass", true, classLoader1);
        System.out.println(loadClass.equals(loadClass1));//输出false
    }
}

public class FastThreadLocalTest {


    public static void main(String[] args) {
        testFast(100);
        testSlow(100);
    }

    private static void testFast(int threadLocalCount) {
        final FastThreadLocal<String>[] caches = new FastThreadLocal[threadLocalCount];
        final Thread mainThread = Thread.currentThread();
        for (int i = 0; i < threadLocalCount; i++) {
            caches[i] = new FastThreadLocal();
        }
        Thread t = new FastThreadLocalThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < threadLocalCount; i++) {
                    caches[i].set("float.lu");
                }
                long start = System.nanoTime();
                for (int i = 0; i < threadLocalCount; i++) {
                    for (int j = 0; j < 1000000; j++) {
                        caches[i].get();
                    }
                }
                long end = System.nanoTime();
                System.out.println("take[" + TimeUnit.NANOSECONDS.toMillis(end - start) +
                        "]ms");
                LockSupport.unpark(mainThread);
            }

        });
        t.start();
        LockSupport.park(mainThread);
    }

    private static void testSlow(int threadLocalCount) {
        final ThreadLocal<String>[] caches = new ThreadLocal[threadLocalCount];
        final Thread mainThread = Thread.currentThread();
        for (int i=0;i<threadLocalCount;i++) {
            caches[i] = new ThreadLocal();
        }
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<threadLocalCount;i++) {
                    caches[i].set("float.lu");
                }
                long start = System.nanoTime();
                for (int i=0;i<threadLocalCount;i++) {
                    for (int j=0;j<1000000;j++) {
                        caches[i].get();
                    }
                }
                long end = System.nanoTime();
                System.out.println("take[" + TimeUnit.NANOSECONDS.toMillis(end - start) +
                        "]ms");
                LockSupport.unpark(mainThread);
            }

        });
        t.start();
        LockSupport.park(mainThread);
    }
}

//输出
fast[15]ms
slow[302]ms

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
        
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

public final V get(InternalThreadLocalMap threadLocalMap) {
        Object v = threadLocalMap.indexedVariable(index);
        if (v != InternalThreadLocalMap.UNSET) {
            return (V) v;
        }

        return initialize(threadLocalMap);
    }
    
public Object indexedVariable(int index) {
        Object[] lookup = indexedVariables;
        return index < lookup.length? lookup[index] : UNSET;
    }

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

public final void set(V value) {
        if (value != InternalThreadLocalMap.UNSET) {
            InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
            if (setKnownNotUnset(threadLocalMap, value)) {
                registerCleaner(threadLocalMap);
            }
        } else {
            remove();
        }
    }
    
public boolean setIndexedVariable(int index, Object value) {
        Object[] lookup = indexedVariables;
        if (index < lookup.length) {
            Object oldValue = lookup[index];
            lookup[index] = value;
            return oldValue == UNSET;
        } else {
            expandIndexedVariableTableAndSet(index, value);
            return true;
        }
    }

public FastThreadLocal() {
        index = InternalThreadLocalMap.nextVariableIndex();
    }

Object[] indexedVariables;


public static int nextVariableIndex() {
        int index = nextIndex.getAndIncrement();
        if (index < 0) {
            nextIndex.decrementAndGet();
            throw new IllegalStateException("too many thread-local indexed variables");
        }
        return index;
    }

//HelloService.thrfit
namespace java com.jack.thrift
service HelloService{
    string helloString(1:string what)
}

运行  thrift -gen HelloService.thrfit

public class ThriftServer {

    /**
     * 启动thrift服务器
     * @param args
     */
    public static void main(String[] args) throws Exception {
        try {
            System.out.println("服务端开启....");
            TProcessor tprocessor = new HelloService.Processor<HelloService.Iface>(new HelloServiceImpl());
            // 简单的单线程服务模型
            TServerSocket serverTransport = new TServerSocket(9898);
            TServer.Args tArgs = new TServer.Args(serverTransport);
            tArgs.processor(tprocessor);
            tArgs.protocolFactory(new TBinaryProtocol.Factory());
            TServer server = new TSimpleServer(tArgs);
            server.serve();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

}

public class ThriftClient {

    public static void main(String[] args) {
        System.out.println("客户端启动....");
        TTransport transport = null;
        try {
            transport = new TSocket("localhost", 9898, 30000);
            // 协议要和服务端一致
            TProtocol protocol = new TBinaryProtocol(transport);
            HelloService.Client client = new HelloService.Client(protocol);
            transport.open();
            String result = client.helloString("哈哈");
            System.out.println(result);
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        } finally {
            if (null != transport) {
                transport.close();
            }
        }
    }
}

HelloService.Client client = new HelloService.Client(protocol);
String result = client.helloString("哈哈");

public String helloString(String what) throws org.apache.thrift.TException
    {
      send_helloString(what);
      return recv_helloString();
    }

public void send_helloString(String what) throws org.apache.thrift.TException
    {
      helloString_args args = new helloString_args();
      args.setWhat(what);
      sendBase("helloString", args);
    }

private void sendBase(String methodName, TBase<?,?> args, byte type) throws TException {
   oprot_.writeMessageBegin(new TMessage(methodName, type, ++seqid_));
   args.write(oprot_);
   oprot_.writeMessageEnd();
   oprot_.getTransport().flush();
 }

public void writeI32(int i32) throws TException {
    inoutTemp[0] = (byte)(0xff & (i32 >> 24));
    inoutTemp[1] = (byte)(0xff & (i32 >> 16));
    inoutTemp[2] = (byte)(0xff & (i32 >> 8));
    inoutTemp[3] = (byte)(0xff & (i32));
    trans_.write(inoutTemp, 0, 4);
  }

public void writeString(String str) throws TException {
    try {
      byte[] dat = str.getBytes("UTF-8");
      writeI32(dat.length);
      trans_.write(dat, 0, dat.length);
    } catch (UnsupportedEncodingException uex) {
      throw new TException("JVM DOES NOT SUPPORT UTF-8");
    }
  }

public void write(byte[] buf, int off, int len) throws TTransportException {
    if (outputStream_ == null) {
      throw new TTransportException(TTransportException.NOT_OPEN, "Cannot write to null outputStream");
    }
    try {
      outputStream_.write(buf, off, len);
    } catch (IOException iox) {
      throw new TTransportException(TTransportException.UNKNOWN, iox);
    }
  }

outputStream_ = new BufferedOutputStream(socket_.getOutputStream(), 1024);

public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
    private static final org.slf4j.Logger _LOGGER = org.slf4j.LoggerFactory.getLogger(Processor.class.getName());
    public Processor(I iface) {
      super(iface, getProcessMap(new java.util.HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
    }

    protected Processor(I iface, java.util.Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
      super(iface, getProcessMap(processMap));
    }

    private static <I extends Iface> java.util.Map<String,  org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> getProcessMap(java.util.Map<String, org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
      processMap.put("helloString", new helloString());
      return processMap;
    }

    public static class helloString<I extends Iface> extends org.apache.thrift.ProcessFunction<I, helloString_args> {
      public helloString() {
        super("helloString");
      }

      public helloString_args getEmptyArgsInstance() {
        return new helloString_args();
      }

      protected boolean isOneway() {
        return false;
      }

      @Override
      protected boolean handleRuntimeExceptions() {
        return false;
      }

      public helloString_result getResult(I iface, helloString_args args) throws org.apache.thrift.TException {
        helloString_result result = new helloString_result();
        result.success = iface.helloString(args.what);
        return result;
      }
    }

  }

public static class helloString<I extends Iface> extends org.apache.thrift.ProcessFunction<I, helloString_args> {
      public helloString() {
        super("helloString");
      }

      public helloString_args getEmptyArgsInstance() {
        return new helloString_args();
      }

      protected boolean isOneway() {
        return false;
      }

      @Override
      protected boolean handleRuntimeExceptions() {
        return false;
      }

      public helloString_result getResult(I iface, helloString_args args) throws org.apache.thrift.TException {
        helloString_result result = new helloString_result();
        result.success = iface.helloString(args.what);
        return result;
      }
    }

client = serverTransport_.accept();
        if (client != null) {
          processor = processorFactory_.getProcessor(client);
          inputTransport = inputTransportFactory_.getTransport(client);
          outputTransport = outputTransportFactory_.getTransport(client);
          inputProtocol = inputProtocolFactory_.getProtocol(inputTransport);
          outputProtocol = outputProtocolFactory_.getProtocol(outputTransport);
          if (eventHandler_ != null) {
            connectionContext = eventHandler_.createContext(inputProtocol, outputProtocol);
          }
          while (true) {
            if (eventHandler_ != null) {
              eventHandler_.processContext(connectionContext, inputTransport, outputTransport);
            }
            if(!processor.process(inputProtocol, outputProtocol)) {
              break;
            }
          }

public boolean process(TProtocol in, TProtocol out) throws TException {
    TMessage msg = in.readMessageBegin();
    ProcessFunction fn = processMap.get(msg.name);
    if (fn == null) {
      TProtocolUtil.skip(in, TType.STRUCT);
      in.readMessageEnd();
      TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
      out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
      x.write(out);
      out.writeMessageEnd();
      out.getTransport().flush();
      return true;
    }
    fn.process(msg.seqid, in, out, iface);
    return true;
  }