线程通信

一、线程是如何通信的

package org.java.test;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.FutureTask;

public class ThreadCommunication {

	/**
	 * 让一个线程等待另一个线程执行完毕再执行
	 */
	private static void demo1() {
	    Thread A = new Thread(new Runnable() {
	        @Override
	        public void run() {
	            printNumber("A");
	        }
	    });
	    Thread B = new Thread(new Runnable() {
	        @Override
	        public void run() {
	        	System.out.println("B 开始等待 A");
	        	try {
					A.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
	        	System.out.println();
	            printNumber("B");
	        }
	    });
	    A.start();
	    B.start();
	}
	
	/**
	 * 打印1到3（模拟任务）
	 * @param threadName
	 */
	private static void printNumber(String threadName) {
	    int i=0;
	    while (i++ < 3) {
	        try {
	            Thread.sleep(100);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        System.out.println(threadName + "print:" + i);
	    }
	}
	
	/**
	 * 让 两个线程按照指定方式有序交叉运行
	 */
	private static void demo3() {
	    Object lock = new Object();
	    Thread A = new Thread(new Runnable() {
	        @Override
	        public void run() {
	            synchronized (lock) {
	                System.out.println("A 1");
	                System.out.println("A waiting…");
	                try {
	                    lock.wait();
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
	                System.out.println("A 2");
	                System.out.println("A 3");
	            }
	        }
	    });
	    Thread B = new Thread(new Runnable() {
	        @Override
	        public void run() {
	            synchronized (lock) {
	                System.out.println("B 1");
	                System.out.println("B 2");
	                System.out.println("B 3");
	                lock.notify();
	            }
	        }
	    });
	    A.start();
	    try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	    B.start();
	}
	
	/**
	 * 四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 A B C 是同步运行的
	 */
	private static void runDAfterABC() {
	    int worker = 3;
	    CountDownLatch countDownLatch = new CountDownLatch(worker);
	    new Thread(new Runnable() {
	        @Override
	        public void run() {
	            System.out.println("D is waiting for other three threads");
	            try {
	                countDownLatch.await();
	                System.out.println("All done, D starts working");
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	    }).start();
	    for (char threadName='A'; threadName <= 'C'; threadName++) {
	        final String tN = String.valueOf(threadName);
	        new Thread(new Runnable() {
	            @Override
	            public void run() {
	                System.out.println(tN + "is working");
	                try {
	                    Thread.sleep(100);
	                } catch (Exception e) {
	                    e.printStackTrace();
	                }
	                System.out.println(tN + "finished");
	                countDownLatch.countDown();
	            }
	        }).start();
	    }
	}
	
	/**
	 * 三个线程都准备好，再一起执行
	 */
	private static void runABCWhenAllReady() {
	    int runner = 3;
	    CyclicBarrier cyclicBarrier = new CyclicBarrier(runner);
	    final Random random = new Random();
	    for (char runnerName='A'; runnerName <= 'C'; runnerName++) {
	        final String rN = String.valueOf(runnerName);
	        new Thread(new Runnable() {
	            @Override
	            public void run() {
	                long prepareTime = random.nextInt(10000) + 100;
	                System.out.println(rN + " is preparing for time:" + prepareTime);
	                try {
	                    Thread.sleep(prepareTime);
	                } catch (Exception e) {
	                    e.printStackTrace();
	                }
	                try {
	                    System.out.println(rN + "is prepared, waiting for others");
	                    cyclicBarrier.await(); // 当前线程准备完毕，等待别人准备好
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                } catch (BrokenBarrierException e) {
	                    e.printStackTrace();
	                }
	                System.out.println(rN + "starts running"); // 所有线程都准备好了，一起开始执行
	            }
	        }).start();
	    }
	}
	
	/**
	 * 子线程完成某件任务后，把得到的结果回传给主线程
	 * 注意，它获取结果的 get 方法会阻塞主线程。
	 */
	private static void doTaskWithResultInWorker() {
	    Callable<Integer> callable = new Callable<Integer>() {
	        @Override
	        public Integer call() throws Exception {
	            System.out.println("Task starts");
	            Thread.sleep(5000);
	            int result = 0;
	            for (int i=0; i<=100; i++) {
	                result += i;
	            }
	            System.out.println("Task finished and return result");
	            return result;
	        }
	    };
	    FutureTask<Integer> futureTask = new FutureTask<>(callable);
	    new Thread(futureTask).start();
	    
	    try {
	        System.out.println("Before futureTask.get()");
	        System.out.println("Result:" + futureTask.get());
	        System.out.println("After futureTask.get()");
	    } catch (Exception e) {
	        e.printStackTrace();
	    }
	}
	
	public static void main(String[] args) {
		doTaskWithResultInWorker();
	}
}

 

---

二、线程池

package org.java.test;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorServiceTest {  
    public static void main(String[] args) {  
        ExecutorService executorService = Executors.newCachedThreadPool();  
        List<Future<String>> resultList = new ArrayList<Future<String>>(); 
        
        // 创建10个任务并执行  
        for (int i = 0; i < 10; i++) {  
            // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中  
            Future<String> future = executorService.submit(new TaskWithResult(i));  
            // 将任务执行结果存储到List中  
            resultList.add(future);  
        }  
        executorService.shutdown();  

        // 遍历任务的结果  
        for (Future<String> fs : resultList) {  
            try {  
                System.out.println(fs.get()); // 打印各个线程（任务）执行的结果  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (ExecutionException e) {  
                e.printStackTrace();  
                return;  
            }  
        }  
    }  
}  

class TaskWithResult implements Callable<String> {  
    private int id;  

    public TaskWithResult(int id) {  
        this.id = id;  
    }  

    /** 
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法，则该方法自动在一个线程上执行。 
     *  
     * @return 
     * @throws Exception 
     */  
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());  
        if (new Random().nextBoolean())  
            throw new TaskException("Meet error in task." + Thread.currentThread().getName());  
        // 一个模拟耗时的操作  
        for (int i = 999999999; i > 0; i--)  
            ;  
        return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();  
    }  
}  

class TaskException extends Exception {  
    public TaskException(String message) {  
        super(message);  
    }  
}