一、简介
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 {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("FirstThread.run[线程一]......" + i);
}
}
}
/**
* 线程二
*/
class SecondThread extends Thread {
@Override
public 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 {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("ThreadFirst.run[线程一]......" + i);
}
}
}
/**
* 线程二
*/
class ThreadSecond implements Runnable {
@Override
public 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> {
@Override
public String call() throws Exception {
for (int i = 0; i < 5; i++) {
System.out.println("ThreadFirstCallable.call[线程一]......" + i);
}
return "ThreadSecondCallable";
}
}
class ThreadSecondCallable implements Callable<Integer> {
@Override
public 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 {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("FirstThread.run[线程一]......" + i);
}
}
}
/**
* 线程二
*/
class SecondThread implements Runnable {
@Override
public 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中创建线程的几种方式,具体根据需求采用不同的方式,推荐使用线程池方式,避免频繁创建销毁线程,有利于减少系统开销。本文只是作者的一些总结以及理解,仅供大家学习参考。