Java多线程实现的几种方式
1.继承thread类
2.实现Runnable接口
3.通过Callable和FutureTask创建线程
4.使用线程池方式—Callable接口
5.使用线程池方式--Runnable接口
1.继承thread类
继承thread类,重写run()方法,start()启动线程
public class TestThread extends Thread{
//创建线程的方式1:继承thread类,重写run方法,start()启动线程
@Override
public void run() { //run方法线程体
for(int i=0;i<200;i++){
System.out.println("run方法线程体"+i);
}
}
public static void main(String[] args) {//主线程
//创建一个线程对象
TestThread t=new TestThread();
//调用start()方法开启线程,从结果看开启之后,不一定立即启动,由CPU随机调度
t.start();
for (int i = 0; i <1000 ; i++) {
System.out.println("main方法线程体"+i);
}
}
}
2.实现Runnable接口
实现Runnable接口,并覆盖run方法,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数,start()启动线程
public class TestThread1 implements Runnable{
//创建线程的方式2:实现Runnable接口,并覆盖run方法,
// 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。start()启动线程
public void run() { //run方法线程体
for(int i=0;i<200;i++){
System.out.println("run方法线程体"+i);
}
}
public static void main(String[] args) {//主线程
//创建runnable接口的实例对象
TestThread1 t=new TestThread1();
//创建一个线程对象,通过线程对象开启线程对象
Thread thread=new Thread(t);
thread.start();
for (int i = 0; i <1000 ; i++) {
System.out.println("main方法线程体"+i);
}
}
}
3.通过Callable和FutureTask创建线程
1.创建Callable接口的实现类,并实现call()方法
2.创建Callable实现类的实例,使用FutrueTask类进行包装Callable对象
3.使用FutureTask对象作为Thread对象启动新线程
4.调用FutureTask对象的get()方法获取子线程执行结束后的返回值
与实现runnable接口不同点:
Callable在任务结束后,可以提供返回值;
Callable中的call()可以抛出异常,run()就不行;
运行Callable可以拿到Future对象,该对象表示异步计算的结果,提供检查是否完成方法。
import java.util.concurrent.*;
public class TestThread2 implements Callable<Object> {
//创建线程的方式3:通过Callable和FutureTask创建线程
//①、创建Callable接口的实现类,并实现call()方法,改方法将作为线程执行体,且具有返回值。
//②、创建Callable实现类的实例,使用FutrueTask类进行包装Callable对象,FutureTask对象封装了Callable对象的call()方法的返回值
//③、使用FutureTask对象作为Thread对象启动新线程。
//④、调用FutureTask对象的get()方法获取子线程执行结束后的返回值。
//与实现runnable接口不同点:
// 1.Callable在任务结束后,可以提供返回值;
// 2.Callable中的call()可以抛出异常,run()就不行;
// 3.运行Callable可以拿到Future对象,该对象表示异步计算的结果,提供检查是否完成方法。
@Override
public Object call() throws Exception{
int i=0;
for(;i<200;i++){
String name=Thread.currentThread().getName();
System.out.println(name+"的变量值为"+i);
}
return i;
}
public static void main(String[] args) {
//创建Callable实现类的实例
TestThread2 thread=new TestThread2();
//使用FutrueTask类进行包装Callable对象
FutureTask future=new FutureTask(thread);
try {
//使用FutureTask对象作为Thread对象启动新线程。
Thread t=new Thread(future);
t.start();
Object o = future.get(); //获取返回结果
System.out.println(o.toString());
}catch (Exception e){
e.printStackTrace();
}
}
}
4.使用线程池方式—Callable接口
- 创建Callable接口的实现类,并实现call()方法
- 创建线程池对象
- 创建Callable接口子类对象
- 提交Callable接口子类对象
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestThread3 implements Callable {
// 创建线程的方式4:使用线程池方式—Callable接口
// 使用线程池中线程对象的步骤:
// 创建线程池对象
// 创建Callable接口子类对象
// 提交Callable接口子类对象
// 关闭线程池
@Override
public Object call() throws Exception {
int i=0;
for (; i <200 ; i++) {
String name=Thread.currentThread().getName();
System.out.println(name+"的变量值为"+i);
}
return i;
}
public static void main(String[] args) {
//创建线程池对象,包含2个线程对象
ExecutorService service=Executors.newFixedThreadPool(2);//ExecutorService:线程池类
//创建Callable对象
TestThread3 thread=new TestThread3();
try{
//从线程池中获取线程对象
Future<Object> future=service.submit(thread);//submit获取线程池中的某一个
//线程对象,并执行线程中的call()方法
//submit方法执行结束后,将使用完的线程又归还到了线程池中,线程的关闭由线程池控制。
System.out.println(future.get());
}catch (Exception e){
e.printStackTrace();
}
//关闭线程池
service.shutdown();
}
}
5.使用线程池方式--Runnable接口
- 创建Runnable接口的实现类,并重写run()方法
- 创建线程池对象
- 创建Runnable接口子类对象
- 提交Runnable接口子类对象
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestThread4 implements Runnable{ // 创建线程的方式4: 使用线程池方式--Runnable接口 // 使用线程池中线程对象的步骤: // 创建线程池对象 // 创建Runnable接口子类对象 // 提交Runnable接口子类对象 // 关闭线程池 @Override public void run() { for (int i=0; i <200 ; i++) { String name=Thread.currentThread().getName(); System.out.println(name+"的变量值为"+i); } } public static void main(String[] args) { //创建线程池对象,包含2个线程对象 ExecutorService service=Executors.newFixedThreadPool(2); //创建Callable对象 TestThread4 thread=new TestThread4(); //自己创建线程对象的方式 Thread t = new Thread(thread); t.start(); //从线程池中获取线程对象,然后调用TestThread4中的run() service.submit(thread); //关闭线程池 service.shutdown(); } }