Java多线程并发技术

1.      int taskSize = 5;     
2.    ExecutorService pool = Executors.newFixedThreadPool(taskSize);  // 创建一个线程池  
3.    // 创建多个有返回值的任务  
4.    List<Future> list = new ArrayList<Future>();  
5.    for (int i = 0; i < taskSize; i++) {  
6.     Callable c = new MyCallable(i + " ");     
7.     Future f = pool.submit(c);      // 执行任务并获取Future对象  
8.     list.add(f);  
9.    }     
10.   pool.shutdown();    // 关闭线程池   
11. for (Future f : list) {  
12.  // 从Future对象上获取任务的返回值，并输出到控制台  
13.  System.out.println(">>>" + f.get().toString());   //get()是阻塞调用
14.  }   

  // 实现Callable接口

1. class MyCallable implements Callable<Object> {  
2. private String taskNum;    
3. MyCallable(String taskNum) {  
4.    this.taskNum = taskNum;  
5. }    
6. public Object call() throws Exception {     
7.    Thread.sleep(1000);   
8.    return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
9. }  

10. } 

1. public class CallableAndFuture {  
2.     public static void main(String[] args) {  
3.         Callable<Integer> callable = new Callable<Integer>() {  
4.             public Integer call() throws Exception {  
5.                 return new Random().nextInt(100);  
6.             }  
7.         };  
8.          FutureTask<Integer> future = new FutureTask<Integer>(callable);  
9.       new Thread(future).start();  
10.        try {  
11.           Thread.sleep(5000);// 可能做一些事情  
12.           System.out.println(future.get());  
13.      } catch (InterruptedException e) {  
14.           e.printStackTrace();  
15.        } catch (ExecutionException e) {  
16.           e.printStackTrace();  
17.        }  
18.    }  

     19.  }  

1.  public class CallableAndFuture {  
2.     public static void main(String[] args) {  
3.      ExecutorService threadPool = Executors.newCachedThreadPool();  
4.         CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(threadPool);  
5.         for(int i = 1; i < 5; i++) {  
6.             final int taskID = i;  
7.             cs.submit(new Callable<Integer>() {  
8.                 public Integer call() throws Exception {  
9.                     return taskID;  
10.              }  
11.            });  
12.          }  
13.          // 可能做一些事情  
14.          for(int i = 1; i < 5; i++) {  
15.              try {  

        //take 每次获得一个执行完成的future，如果没有就阻塞，与其功能相同的非阻塞调用时poll

1.                 System.out.println(cs.take().get());  
2.            } catch (InterruptedException e) {  
3.                  e.printStackTrace();  
4.             } catch (ExecutionException e) {  
5.                 e.printStackTrace();  
6.              }  
7.          }  
8.       }  

       }  

1. public class JoinTest {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         JoinThread t1 = new JoinThread("t1");  
4.         JoinThread t2 = new JoinThread("t2");  
5.         t1.start();   //启动线程
6.         t2.start();  //启动线程
7.         t1.join();   //等待该线程执行完毕
8.         t2.join();  //
9.         System.out.println("主线程开始执行！");  
10.    }  

11. }  

      class JoinThread extends Thread {  

1.      public JoinThread(String name) {  
2.        super(name);  
3.        }  
4.       public void run() {  
5.        for(int i = 1; i <= 10; i++)  
6.             System.out.println(getName() + getId() + "执行了" + i + "次");  
7.      }  

    }