Java创建多线程的方法总结

一、简介

Java中创建线程主要有四种方式，分别是：

【a】继承Thread类，实现run()方法；

【b】实现Runnable接口，实现run()方法；

【c】通过实现Callable接口，实现call()方法，结合FutureTask创建线程；

【d】通过线程池创建，主要使用ExecutorService、Executors等

下面将具体对每一种方法进行讲解。

二、继承Thread方式

【a】调用start()方法启动线程,不要调用run(),调用run()相当于普通方法调用.;
【b】 main()方法也是一个线程,主线程,main线程;

/*** @Title: FirstThreadCreatedMethod* @ProjectName java_thread* @Description: 多线程创建方法一: 继承Thread类,重写run()方法* @Author WeiShiHuai* @Date 2018/11/6 10:41* <p>* 说明:* 1. 调用start()方法启动线程,不要调用run(),调用run()相当于普通方法调用.* 2. main()方法也是一个线程,主线程,main线程*/
public class FirstThreadCreatedMethod {public static void main(String[] args) {FirstThread firstThread = new FirstThread();SecondThread secondThread = new SecondThread();//调用start()方法启动线程firstThread.start();secondThread.start();//        调用run()相当于普通方法调用,从上往下依次执行方法
//        firstThread.run();
//        secondThread.run();//主线程for (int i = 0; i < 5; i++) {System.out.println("FirstThreadCreatedMethod.main[Main线程]......" + i);}}}/*** 线程一*/
class FirstThread extends Thread {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("FirstThread.run[线程一]......" + i);}}
}/*** 线程二*/
class SecondThread extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("SecondThread.run[线程二]......" + i);}}
}

运行结果：多个线程交叉执行，具体决定于CPU的调度。

注意：要使用thread.start()方法来启动线程，不要使用run()，相当于普通方法执行了，多个线程只会顺序执行，如下图：线程只能一个执行完了再执行另外一个。

三、实现Runnable方式

【a】实现Runnable方式创建线程实际上使用了静态代理模式;
【b】通过public Thread(Runnable target) {} 传入Runnable实例对象进行创建线程;
【c】调用start()方法启动线程;

/*** @Title: SecondThreadCreatedMethod* @ProjectName java_thread* @Description: 多线程创建方法二: 实现Runnable接口,重写run()方法* @Author WeiShiHuai* @Date 2018/11/6 11:08* <p>* 说明:* 1. 实现Runnable方式创建线程实际上使用了静态代理模式* 2. 通过public Thread(Runnable target) {} 传入Runnable实例对象进行创建线程* 3. 调用start()方法启动线程*/
public class SecondThreadCreatedMethod {public static void main(String[] args) {//传入实现Runnable接口的线程实例对象Thread t1 = new Thread(new ThreadFirst());Thread t2 = new Thread(new ThreadSecond());//调用start()启动线程t1.start();t2.start();//主线程for (int i = 0; i < 5; i++) {System.out.println("SecondThreadCreatedMethod.main[Main线程]......" + i);}}}/*** 线程一*/
class ThreadFirst implements Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("ThreadFirst.run[线程一]......" + i);}}
}/*** 线程二*/
class ThreadSecond implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("ThreadSecond.run[线程二]......" + i);}}
}

运行结果：多个线程交叉执行，每一次运行都可能不一样，具体看CPU怎么调度。

四、Callable方式

【a】实现Callable接口,重写call()方法,可以指定泛型,可以获取返回结果;
【b】创建FutureTask,传入Callable实例对象;
【c】new Thread(FutureTask task)创建线程;
【d】调用thread.start()启动线程;

/*** @Title: ThirdThreadCreatedMethod* @ProjectName java_thread* @Description: 多线程创建方法三: 实现Callable接口,重写call()方法,利用FutureTask创建线程,new Thread(futureTask)* @Author WeiShiHuai* @Date 2018/11/6 11:36* <p>* 说明:* 1. 实现Callable接口,重写call(),可以指定泛型,可以获取返回结果* 2. 创建FutureTask,传入Callable实例对象* 3. new Thread(FutureTask task)创建线程* 4. 调用thread.start()启动线程*/
public class ThirdThreadCreatedMethod {public static void main(String[] args) {//创建FutureTask对象FutureTask<String> firstFutureTask = new FutureTask<>(new ThreadFirstCallable());FutureTask<Integer> secondFutureTask = new FutureTask<>(new ThreadSecondCallable());//创建线程Thread对象,调用start()方法启动线程new Thread(firstFutureTask).start();new Thread(secondFutureTask).start();//获取线程执行后返回的数据try {String result = firstFutureTask.get();System.out.println("result = " + result);Integer num = secondFutureTask.get();System.out.println("num = " + num);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}//主线程for (int i = 0; i < 15; i++) {System.out.println("ThirdThreadCreatedMethod.main[线程Main]......" + i);}}}class ThreadFirstCallable implements Callable<String> {@Overridepublic String call() throws Exception {for (int i = 0; i < 5; i++) {System.out.println("ThreadFirstCallable.call[线程一]......" + i);}return "ThreadSecondCallable";}
}class ThreadSecondCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {for (int i = 0; i < 5; i++) {System.out.println("ThreadSecondCallable.call[线程二]......" + i);}return 1;}
}

运行结果：多个线程交叉执行。

如下图，可以获取到线程执行返回的结果，即在call()方法中返回的结果。

五、线程池方式

线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度。

【a】创建ExecutorService对象,根据具体需求创建合适的线程池.
【b】使用executorService.submit()方法,传入Runnable实例对象.(也可以传入Callable对象,Callable结合submit()这种方式可以获取线程执行完返回的结果)
【c】使用executorService.shutdown()方法销毁线程池.

/*** @Title: FourthThreadCreatedMethod* @ProjectName java_thread* @Description: 多线程创建方法四: 使用线程池创建* @Author WeiShiHuai* @Date 2018/11/6 13:55* <p>* 说明:* 1. 创建ExecutorService对象,根据具体需求创建合适的线程池.* 2. 使用executorService.submit()方法,传入Runnable实例对象.(也可以传入Callable对象,Callable结合submit()这种方式可以获取线程执行完返回的结果)* 3. 使用executorService.shutdown()方法销毁线程池.*/
public class FourthThreadCreatedMethod {public static void main(String[] args) {//创建线程池//newFixedThreadPool: 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待.ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个可缓存线程池，如果线程池长度超过处理需要，可回收空闲线程，若无可回收，则新建线程.
//        ExecutorService executorService2 = Executors.newCachedThreadPool();//创建一个定长线程池，支持定时及周期性任务执行
//        ExecutorService executorService3 = Executors.newScheduledThreadPool(3);//创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
//        ExecutorService executorService4 = Executors.newSingleThreadExecutor();for (int i = 0; i < 5; i++) {//为线程池分配任务executorService.submit(new FirstThread());executorService.submit(new SecondThread());}//main线程for (int i = 0; i < 5; i++) {System.out.println("FourthThreadCreatedMethod.main[main线程]......" + i);}//销毁线程池executorService.shutdown();}
}/*** 线程一*/
class FirstThread implements Runnable {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("FirstThread.run[线程一]......" + i);}}
}/*** 线程二*/
class SecondThread implements Runnable {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("SecondThread.run[线程二]......" + i);}}
}

运行结果：多个线程交叉执行。

六、优缺点

【a】继承Thread类方式：

优点：创建线程比较简单，只需继承实现即可；另外如果需要获取当前线程，可以直接使用this获取。

缺点：因为Java是单继承的，如果继承了Thread，说明该类不能再继承其他类，扩展性不好。

【b】使用Runnable接口方式：

优点：线程类只是实现了Runnable接口或Callable接口，还可以继承其他类；另外多个线程可以共享同一份资源。

缺点：如果需要访问当前线程，则必须使用Thread.currentThread()来获取当前线程对象。

【c】使用Callable接口方式：

优点：线程类只是实现了Runnable接口或Callable接口，还可以继承其他类；另外多个线程可以共享同一份资源。

缺点：如果需要访问当前线程，则必须使用Thread.currentThread()来获取当前线程对象。

【d】使用线程池方式：

优点：避免频繁创建销毁线程，减少系统开销。

缺点：虽然线程池很强大，这样就带来了并发问题。

七、总结

以上是关于Java中创建线程的几种方式，具体根据需求采用不同的方式，推荐使用线程池方式，避免频繁创建销毁线程，有利于减少系统开销。本文只是作者的一些总结以及理解，仅供大家学习参考。