1、串行程序

　　串行程序是基于嵌入式Linux串行通信GUI終端設計及實現(xiàn)。傳統(tǒng)意義上的寫法，我們得到的往往會是串行執(zhí)行的程序形態(tài)，程序的總的執(zhí)行時間是method1的執(zhí)行時間time1加上method2的執(zhí)行時間time2，這樣總的執(zhí)行時間time=time1+time2。我們得到的是串行的程序形態(tài)。

　　import com.yang.domain.BaseResult;

　　import org.junit.Test;

　　import java.util.concurrent.TimeUnit;

　　/**

　　* @Description：

　　* @Author： yangzl2008

　　* @Date： 2016/1/9 19:06

　　*/

　　public class Serial {

　　@Test

　　public void test（） {

　　long start = System.currentTimeMillis（）;

　　BaseResult baseResult1 = method1（）;// 耗時操作1，時間 time1

　　BaseResult baseResult2 = method2（）;// 耗時操作2，時間 time2

　　long end = System.currentTimeMillis（）;

　　//總耗時 time = time1 + time2

　　System.out.println（“baseResult1 is ” + baseResult1 + “\nbaseResult2 is ” + baseResult2 + “\ntime cost is ” + （end - start））;

　　}

　　private BaseResult method1（） {

　　BaseResult baseResult = new BaseResult（）;

　　try {

　　TimeUnit.SECONDS.sleep（1）;

　　} catch （InterruptedException e） {

　　e.printStackTrace（）;

　　}

　　baseResult.setCode（1）;

　　baseResult.setMsg（“method1”）;

　　return baseResult;

　　}

　　private BaseResult method2（） {

　　BaseResult baseResult = new BaseResult（）;

　　try {

　　TimeUnit.SECONDS.sleep（1）;

　　} catch （InterruptedException e） {

　　e.printStackTrace（）;

　　}

　　baseResult.setCode（1）;

　　baseResult.setMsg（“method2”）;

　　return baseResult;

　　}

　　}

　　執(zhí)行結果：

　　［plain］

　　BaseResult{code=1， msg=‘method1’}

　　baseResult2 is BaseResult{code=1， msg=‘method2’}

　　time cost is 2000

　　2、串行程序的多線程過渡

　　而這種代碼是不是可優(yōu)化的地方呢？加快程序的執(zhí)行效率，降低程序的執(zhí)行時間。在這里method1和method2是相互不關聯(lián)的，即method1的執(zhí)行和method2的執(zhí)行位置可以調整，而不影響程序的執(zhí)行結果，我們可不可以為建立線程1執(zhí)行method1然后建立線程2來執(zhí)行method2呢，因為method1和method2都需要得到結果，因此我們需要使用Callable接口，然后使用Future.get（）得到執(zhí)行的結果，但實際上Future.get（）在程序返回結果之前是阻塞的，即，線程1在執(zhí)行method1方式時，程序因為調用了Future.get（）會等待在這里直到method1返回結果result1，然后線程2才能執(zhí)行method2，同樣，F(xiàn)uture.get（）也會一直等待直到method2的結果result2返回，這樣，我們開啟了線程1，開啟了線程2并沒有得到并發(fā)執(zhí)行method1，method2的效果，反而會因為程序開啟線程而多占用了程序的執(zhí)行時間，這樣程序的執(zhí)行時間time=time1+time2+time（線程開啟時間）。于是我們得到了串行程序的過渡態(tài)。

　　［java］ view plain copyimport com.yang.domain.BaseResult;

　　import org.junit.Test;

　　import java.lang.reflect.Method;

　　import java.util.concurrent.*;

　　/**

　　* @Description：

　　* @Author： yangzl2008

　　* @Date： 2016/1/9 19:13

　　*/

　　public class SerialCallable {

　　@Test

　　public void test01（） throws Exception {

　　// 兩個線程的線程池

　　ExecutorService executorService = Executors.newFixedThreadPool（2）;

　　long start = System.currentTimeMillis（）;

　　// 開啟線程執(zhí)行

　　Future《BaseResult》 future1 = executorService.submit（new Task（this， “method1”， null））;

　　// 阻塞，直到程序返回。耗時time1

　　BaseResult baseResult1 = future1.get（）;

　　// 開啟線程執(zhí)行

　　Future《BaseResult》 future2 = executorService.submit（new Task（this， “method1”， null））;

　　// 阻塞，直到程序返回。耗時time2

　　BaseResult baseResult2 = future2.get（）;

　　long end = System.currentTimeMillis（）;

　　// 總耗時 time = time1 + time2 + time（線程執(zhí)行耗時）

　　System.out.println（“baseResult1 is ” + baseResult1 + “\nbaseResult2 is ” + baseResult2 + “\ntime cost is ” + （end - start））;

　　}

　　public BaseResult method1（） {

　　BaseResult baseResult = new BaseResult（）;

　　try {

　　TimeUnit.SECONDS.sleep（1）;

　　} catch （InterruptedException e） {

　　e.printStackTrace（）;

　　}

　　baseResult.setCode（1）;

　　baseResult.setMsg（“method1”）;

　　return baseResult;

　　}

　　public BaseResult method2（） {

　　BaseResult baseResult = new BaseResult（）;

　　try {

　　TimeUnit.SECONDS.sleep（1）;

　　} catch （InterruptedException e） {

　　e.printStackTrace（）;

　　}

　　baseResult.setCode（1）;

　　baseResult.setMsg（“method2”）;

　　return baseResult;

　　}

　　class Task《T》 implements Callable《T》 {

　　private Object object;

　　private Object［］ args;

　　private String methodName;

　　public Task（Object object， String methodName， Object［］ args） {

　　this.object = object;

　　this.args = args;

　　this.methodName = methodName;

　　}

　　@Override

　　public T call（） throws Exception {

　　Method method = object.getClass（）.getMethod（methodName）;

　　return （T） method.invoke（object， args）;

　　}

　　}

　　}

　　執(zhí)行結果：

　　［plain］

　　BaseResult{code=1， msg=‘method1’}

　　baseResult2 is BaseResult{code=1， msg=‘method1’}

　　time cost is 2001