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

创建线程的几种方式

• 通过实现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
           
             {			@Override			public String call() throws Exception {				System.out.println("正在调用");				return "calling";			}		}				public static void main(String[] args) throws InterruptedException, ExecutionException {			 //2.实例化Callable对象			Callable
            
              callable = new Mycallable();			//3.传入Callable对象，进行构造FutureTask（Runnable的子类）对象			FutureTask
             
               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
           
             cusCallable = new CusCallable();			//3.提交线程到线程池,以submit方式提交			Future runnableFuture = executorService.submit(cusRunable);			//获取执行结果,并打印			Object furuteObject = runnableFuture.get();			System.out.println("furuteObject is "+furuteObject);			Future
            
              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
             
              {			@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支持超时获取结果，指定具体等待时间

转载地址：http://nhjzb.baihongyu.com/