Java多线程处理（二）

1. 主线程不等待

 public class CopyOfTestThreadPool {
 public static void main(String args[]) throws InterruptedException {
  // only two threads

  ExecutorService exec = Executors.newFixedThreadPool(20);
  List list = new ArrayList();
  for(int index = 0; index < 1000000; index++){
   list.add(System.nanoTime());
  }
  
  long start = System.currentTimeMillis();
  for (Long long1 : list) {
   final Long l = long1;
   exec.execute(new Runnable(){

    public void run() {
     System.out.println(l);
     try {
      Thread.sleep(5000);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
     
    }});
  }
  // must shutdown
  exec.shutdown();
   long end = System.currentTimeMillis();
   System.out.print("共计用时 ");
   System.out.println(end  - start);
 }
}




import java.util.ArrayList;    
import java.util.List;    
import java.util.concurrent.Callable;    
import java.util.concurrent.ExecutorService;    
import java.util.concurrent.Executors;    
import java.util.concurrent.Future;    
    
public class Test {    
    
    public static void main(String[] args) {    
        try {    
            List list = new ArrayList<>();    
            for (int i = 0; i < 100; i++) {    
                list.add(i + ",");    
            }    
                
            System.out.println(new Test().list2Str(list, 5));    
        } catch (Exception e) {    
            e.printStackTrace();    
        }    
    }    
    
    public String list2Str(List list, final int nThreads) throws Exception {    
        if (list == null || list.isEmpty()) {    
            return null;    
        }    
            
        StringBuffer ret = new StringBuffer();    
    
        int size = list.size();    
        ExecutorService executorService = Executors.newFixedThreadPool(nThreads);    
        List> futures = new ArrayList>(nThreads);    
            
        for (int i = 0; i < nThreads; i++) {    
            final List subList = list.subList(size / nThreads * i, size / nThreads * (i + 1));    
            Callable task = new Callable() {    
                @Override    
                public String call() throws Exception {    
                    StringBuffer sb = new StringBuffer();    
                    for (String str : subList) {    
                        sb.append(str);    
                    }    
                    return sb.toString();    
                }    
            };    
            futures.add(executorService.submit(task));    
        }    
            
        for (Future future : futures) {    
            ret.append(future.get());    
        }    
        executorService.shutdown();    
            
        return ret.toString();    
    }    
}