一.继承Thread类来创建线程
新建一个类,来继承Thread类,然后重写run方法。main线程中创建新线程的实例,然后调用start()方法即可。
public class MyThread extends Thread{
@Override
public void run() {
//用来描述线程的执行任务
for(int i=1; i<=5; i++){
System.out.println("MyThread线程输出" + i);
}
}
}
/**
* 多线程创建方式1
* 创建新线程类继承Thread类并且重写run方法
*/
public class TreadTest {
public static void main(String[] args) {
//创建MyThread线程类对象代表一个线程
Thread t = new MyThread();
t.start(); //main线程 t线程 t线程自动执行run方法
for(int i=1; i<=5; i++){
System.out.println("主线程main输出" + i);
}
}
}
总结:这种线程创建方式的优点是编码比较简单,缺点是线程类已经继承Thread,无法继承其他类,不利于功能的扩展。
注意事项:
1.不能调用子线程的run方法,一定调用start方法
如果调用run方法,会把子线程当作一个普通Java对象来处理,那么run方法就会先执行。相当于只有一条主线程在跑。start的方法是向cpu或操作系统注册线程。
2.不能把主线程的任务放在子线程之前
容易理解,因为如果放在子线程之前,会先执行主线程的任务,就达不到两条线程并行的效果。
二.实现Runnable接口创建线程
首先创建一个线程任务类MyRunnable实现Runnable接口,重写run方法
主线程中创建线程任务类MyRunnable对象
把MyRunnable任务对象交给Thread处理(Thread类有一个有参构造器,可以传线程人物类对象)
调用线程对象的start方法启动线程
/***
* 定义一个任务类,实现runnable接口,重写run方法
*/
public class ThreadTest2 {
public static void main(String[] args) {
//创建任务对象
Runnable target = new MyRunnable();
//任务对象交给线程对象处理
/* public Thread(Runnable target) {
this(null, target, "Thread-" + nextThreadNum(), 0);
}
*/
new Thread(target).start();
for(int i=1; i<=5; i++){
System.out.println("主线程输出" + i);
}
}
}
public class MyRunnable implements Runnable{
@Override
public void run() {
//线程要执行的任务
for(int i=1; i<=5; i++){
System.out.println("子线程输出" + i);
}
}
}
总结:这种线程创建方式优点是任务类只是实现接口,可以继承其他类,实现其他接口,扩展性更强
简化形式1.
new Thread(new Runnable() {
@Override
public void run() {
for(int i=1; i<=5; i++){
System.out.println("子线程输出" + i);
}
}
}).start();
简化形式二
由于Runnable是函数式的接口,可以通过lambda表达式来简化
//简化形式lambda表达式
new Thread(()->{
for(int i=1; i<=5; i++){
System.out.println("子线程3输出" + i);
}
}).start();
三.实现Callable接口创建线程
前面两种线程创建方式,他们重写run方法均不能返回结果(如果有数据要返回的话)
创建方式:利用Callable接口,FutureTask类来实现
定义一个类实现Callable接口,重写call方法,封装要做的事情,和要返回的数据
把Callable类型对象封装程FutureTask(线程任务对象)
把线程任务对象交给Thread对象,调用start方法
线程执行完毕后,通过FutureTask对象的get方法获取线程任务执行结果
public class MyClass implements Callable<String> {
private int n;
public MyClass(int n) {
this.n = n;
}
@Override
public String call() throws Exception {
//描述线程任务,返回线程执行返回后的结果
//需求,求1~n的和返回
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return "线程求出了1~" + n + "的和" + sum;
}
}
public class ThreadTest3 {
public static void main(String[] args) throws Exception {
//创建Callable对象
Callable<String> callable = new MyClass(100);
//把Callable对象封装成一个FutureTask对象
//因为FutureTask对象实现了Runnable接口,是一个线程任务对象
//可以在线程执行完毕后,用未来任务对象调用get方法获取线程执行完毕的结果
FutureTask<String> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
//这里再创建一个线程执行计算1~200的和
Callable<String> callable2 = new MyClass(200);
FutureTask<String> futureTask2 = new FutureTask<>(callable2);
new Thread(futureTask2).start();
//获取线程执行完毕后返回的结果
//如果上面线程还没执行完,这里是会暂停执行,直至线程跑完
String s = futureTask.get();
System.out.println(s);
String s2 = futureTask2.get();
System.out.println(s2);
}
}
总结:
优点:线程任务类只是实现接口,可以继承继承类和实现接口,扩展性强,并且可以在线程执行完毕后获取线程执行的结果。
缺点:编码复杂