Thread - Thread Execution-白红宇

Thread - Thread Execution

阅读量：4202 次

发布时间：2019-05-26

本文共 5452 字，大约阅读时间需要 18 分钟。

线程运行工具也有两种方法实现：

1、Thread

2、ThreadPool

- Executors.xxx.submit: 运行器 (submit, return Future)

- ThreadPoolExecutor.execute: 线程池运行器 (execute, void)

主要区别：线程池循环使用线程池中的线程，减少创建和销毁线程。

可以用Future接收运行结果

运行体主要有两种方法实现：

1、Runnable(), run()

2、Callable(), call()

主要区别：Run 没有返回值，Call有返回值。

可以把运行体封装成FutureTask。

一、准备线程

1、Thread

Thread t = new Thread([Runnable | Callable]);

2、Thread Pool Executor

ExecutorService executor = Executors.newFixedThreadPool(n);  // n threads; newSingleThreadExecutor(), newScheduledThreadPool(), ...

二、运行体

1、Run

new Runnable() {  public void run() {...}}

2、Call

new Callable
   
    () {  public String call() throws Exception {...; return ...}  // e.g. return String type}

3、FutureTask

Callable
   
     task = ...;  // or RunnableFutureTask
    
      ft = new FutureTask
     
      (task);  // e.g.String

三、运行

1、Thread

t.start();

2、Thread Pool Executor

executor.submit([Callable | Runnable])

3、Future

Future
   
     future = executor.submit(...)  // similar to thread.start

四、Sample

public class Thread01_future extends Thread {	public static void main(String[] args) {		// Future: 异步计算结果		// Thread.start: 运行器		// Executors.xxx.submit: 运行器		// ThreadPoolExecutor.execute: 线程池运行器		// (execute, void) (submit, return Future)		// FutureTask: 异步计算任务		// Runnable(), run(): 运行任务（运行类、运行方法，void）		// Callable(), call(): 运行任务（运行类、运行方法，return）		// test01();		// test02();		test03();	}	// Future: 异步计算结果	// Executors.xxx.submit: 运行器	// Runnable(), run(): 运行任务（运行类、运行方法，void）	// Callable(), call(): 运行任务（运行类、运行方法，return）	public static void test01() {		// 创建一个执行任务的服务		ExecutorService executor = Executors.newFixedThreadPool(3);		try {			// 1. A Runnable, however, does not return a result and cannot throw			// checked exception.			System.out.println("~~~1");			Future
    runnable1 = executor.submit(new Runnable() {				@Override				public void run() {					System.out.println("runnable1 running.");				}			});			System.out.println("Runnable1:" + runnable1.get());			// 2. Callable			System.out.println("~~~2");			Future
   
     future1 = executor.submit(new Callable
    
     () {				@Override				public String call() throws Exception {					return "result=task1";				}			});			System.out.println("task1: " + future1.get());			// 3. 对Callable调用cancel可以对对该任务进行中断			System.out.println("~~~3");			Future
     
       future2 = executor.submit(new Callable
      
       () {				@Override				public String call() throws Exception {					try {						while (true) {							System.out.println("task2 running.");							Thread.sleep(50);						}					} catch (InterruptedException e) {						System.out.println("Interrupted task2.");					}					return "task2=false";				}			});			// 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环			Thread.sleep(101);			System.out.println("task2 cancel: " + future2.cancel(true));			// 4.用Callable时抛出异常则Future什么也取不到了			// 获取第三个任务的输出，因为执行第三个任务会引起异常			// 所以下面的语句将引起异常的抛出			System.out.println("~~~4");			Future
       
         future3 = executor.submit(new Callable
        
         () { @Override public String call() throws Exception { throw new Exception("task3 throw exception!"); } }); // Thread.sleep(133); System.out.println("task3: " + future3.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } // 停止任务执行服务 executor.shutdownNow(); } // FutureTask: 异步计算任务 // Thread, Executors.xxx.submit: 运行器 public static void test02() { Callable
         
           task = new Callable
          
           () { @Override public String call() { System.out.println("Sleep start."); try { Thread.sleep(1000 * 3); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("Sleep end."); return "time=" + System.currentTimeMillis(); } }; // 直接使用Thread的方式执行 FutureTask
           
             ft = new FutureTask
            
             (task); Thread t = new Thread(ft); t.start(); try { System.out.println("waiting execute result"); System.out.println("result = " + ft.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } // 使用Executors来执行 System.out.println("========="); FutureTask
             
               ft2 = new FutureTask
              
               (task); Executors.newSingleThreadExecutor().submit(ft2); try { System.out.println("waiting execute result"); System.out.println("result = " + ft2.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } // ThreadPoolExecutor.execute: 线程池运行器 public static void test03() { int produceTaskMaxNumber = 4; // 构造一个线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue
               
                (10), new ThreadPoolExecutor.DiscardOldestPolicy()); ArrayList
                
                 
                  > tasks = new ArrayList
                  
                   
                    >(); for (int i = 1; i <= produceTaskMaxNumber; i++) { try { // 产生一个任务，并将其加入到线程池 Callable
                    
                      task = new Callable
                     
                      () { @Override public String call() { String task = "task@ "; System.out.println("put " + task); return task; } }; FutureTask
                      
                        futureTask = new FutureTask
                       
                        ( task); threadPool.execute(futureTask); tasks.add(futureTask); } catch (Exception e) { e.printStackTrace(); } } for (FutureTask
                        
                          futureTask : tasks) { // 1秒内获得结果 (1st arg: the maximum time to wait, 2nd arg: the time // unit of the timeout argument) String str = null; try { str = "stop " + futureTask.get(1, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } catch (TimeoutException e) { e.printStackTrace(); } System.out.println(str); } }}