小议创建线程的若干方式

创建线程的几种方式

• 通过实现Runnable接口的run方法
  • 1.继承Runnable接口，重写run方法
  • 2.实例化实现后Runnable子类，调用run方法
  • 3.例子

  		package com.myd.cn.createThreadWay;
  
  public class RunnableWay {
  	/**
  	 *1.实现Runnable的子类
  	 * @author dymll
  	 *
  	 */
  	public static class RunnableThread implements Runnable{
  		@Override
  		public void run() {
  			System.out.println(" Runnable subClass running --- ");
  		}
  	}
  
  	public static void main(String[] args) {
  		//2.实例化子类
  		Runnable runable = new RunnableThread();
  		//3.子类实例调用start()方法
  		runable.run();
  	}
  }
  

• 继承Thread类，重新run方法，调用start启动线程
  • 1.继承Thread类，重写run方法
  • 2.实例化继承后的子类，然后调用start()方法
  • 3.例子

  	package com.myd.cn.createThreadWay;
  
  	public class ThreadWay {
  		/**
  		 * 1.继承Thread的子类
  		 * @author dymll
  		 *
  		 */
  		public static class ThreadDemo extends Thread{
  			@Override
  			public void run() {
  				super.run();
  				System.out.println(" Thread subClass running --- ");
  			}
  		}
  		public static void main(String[] args) {
  				//2.实例化子类
  				Thread threadDemo = new ThreadDemo();
  				//3.子类实例调用start()方法
  				threadDemo.start();
  		}
  
  	}
  
  

• 通过Callable和FutureTask创建线程
  • 1.实现Callable接口，重新call方法
  • 2.实例化已重写传入Callable对象，构造FutureTask(Runnable的子类)对象
  • 3.传入FutureTask对象构造Thread对象，启动线程
  • 4.例子

    	package com.myd.cn.createThreadWay;
    
    	import java.util.concurrent.Callable;
    	import java.util.concurrent.ExecutionException;
    	import java.util.concurrent.FutureTask;
    
    	public class CallableThread {
    		/**
    		 * 1.实现Class接口，创建静态内部类
    		 * @author dymll
    		 *
    		 */
    		public static class Mycallable implements Callable<String> {
    			@Override
    			public String call() throws Exception {
    				System.out.println("正在调用");
    				return "calling";
    			}
    		}
    		
    		public static void main(String[] args) throws InterruptedException, ExecutionException {
    			 //2.实例化Callable对象
    			Callable<String> callable = new Mycallable();
    			//3.传入Callable对象，进行构造FutureTask（Runnable的子类）对象
    			FutureTask<String> futureTask = new FutureTask<>(callable);
    
    			//4.传入FutureTask对象
    			new Thread(futureTask).start();
    
    			//5.使用FutureTask获取线程执行结果
    			String result  = futureTask.get();
    			System.out.println("result = "+result);
    		}
    
    	}
    	
    

• 使用线程池，将Runnable或Callable放入线程池ExecutorService中执行
  • 1.实现Callable/Runnable接口，重写call/run方法
  • 2.构建ExecutorService线程池对象，调用线程池execute/submit方法执行线程
  • 3.对于submit方式提交，使用Future来获取执行结果
  • 4.例子

    	package com.myd.cn.createThreadWay;
    	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 ThreadPoolWay {
    		public static void main(String[] args) throws InterruptedException, ExecutionException {
    			ExecutorService executorService = Executors.newFixedThreadPool(2);
    
    			//2.实例化Runnable子类，Callable子类
    			Runnable cusRunable = new CusRunnable();
    			Callable<String> cusCallable = new CusCallable();
    
    			//3.提交线程到线程池,以submit方式提交
    			Future runnableFuture = executorService.submit(cusRunable);
    			//获取执行结果,并打印
    			Object furuteObject = runnableFuture.get();
    			System.out.println("furuteObject is "+furuteObject);
    			Future<String> callableFuture = executorService.submit(cusCallable);
    			//void类型的run方法无返回值
    			String result = callableFuture.get();
    			System.out.println("callableFuture is "+callableFuture);
    		}
    
    		/**
    		 * 实现Callable接口 call方法，返回线程执行结果
    		 * @author dymll
    		 *
    		 */
    		public static class CusCallable implements Callable<String>{
    
    			@Override
    			public String call() throws Exception {
    				System.out.println("CusCallable is Calling");
    				return "calling";
    			}
    
    		}
    
    		public static class CusRunnable implements Runnable{
    			@Override
    			public void run() {
    				System.out.println("CusRunnable is running");
    			}
    
    		}
    	}
    

如果获取线程执行的结果

- 1.实现Callable接口并重写call方法后的子类实例化后，传入FutureTask，FutureTask实例化后，传入Thread实例化后对象，然后FutureTask实例调用get方法后去线程执行结果
- 2.看FutureTask的run方法
- 3.FutureTask会维护线程的状态，在未完成时会一直等待，直到完成
- 4.FutureTask会把结果和异常信息存储在对象内部变量中
- 5.FutureTask支持超时获取结果，指定具体等待时间