创建线程的三种方式
线程
什么是线程？
线程(thread)是一个程序内部的执行路径
java是通过java.lang.Thread类来代表线程的
多线程的创建创建方式
方式一:继承Thread类，重写Thread类中的run()方法;调用线程对象的start()方法启动线程(启动后还是执行run方法
public class ThreadDemo1 {
/**
* 目标:多线程的创建方式一:继承Thread类*/
public static void main(String[] args) {
//3.new一个线程对象
Thread t=new MyThread();
//4.调用start方法启动线程(执行的还是run方法)
t.run();
for(int i=0;i<5;i++){
System.out.println("主线程执行输出:"+i);
}
}
}
class MyThread extends Thread{
/**
* 1.定义一个线程继承Thread类*/
@Override
public void run() {
/**
* 2.重写run方法，里面是定义线程以后要干啥
* */
for(int i=0;i<5;i++){
System.out.println("子线程执行输出:"+i);
}
}
}
优缺点
1.优点:编码简单
2.缺点:线程类已经继承Thread，无法继承其他类，不利于扩展
注意
为什么不直接调用了run方法，而是调用start启动线程?
直接调用run方法会当成普通方法执行，此时相当于还是单线程执行
方式二:实现Runnable接口，实现run方法;调用线程对象的start()方法启动线程(启动后还是执行run方法)
实现步骤
1.定义一个线程任务类MyRuunable实现Runnable接口，实现run()方法
2.创建MyRunnable任务对象
3.把MyRunnable任务对象交给Thread处理
4.调用线程对象的start()方法启动线程
实现方式一：
public class ThreadDemo2 {
/**
* 目标:多线程的创建方式二:实现Runnable接口
* */
public static void main(String[] args) {
//2.创建MyRunnable任务对象
Runnable my=new MyRunnable();
//3.把MyRunnable任务对象交给Thread处理
Thread thread=new Thread(my);
//调用线程对象的start()方法启动线程
thread.start();
for(int i=0;i<10;i++){
System.out.println("主线程执行输出:"+i);
}
}
}
class MyRunnable implements Runnable{
/**
* 1.定义一个线程实现Runnable接口 实现run()方法
* */
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("子线程执行输出:"+i);
}
}
}
实现方式二：匿名内部类
public class ThreadDemo3 {
/**
* 目标:多线程的创建方式二:实现Runnable接口（匿名内部类形式）
* 1.可以创建Runnable的匿名内部类对象
* 2.交给Thread处理
* 3.调用线程对象的start()启动线程
* */
public static void main(String[] args) {
// Runnable myRunnable=new Runnable() {
// @Override
// public void run() {
// for(int i=0;i<10;i++){
// System.out.println("子线程执行输出:"+i);
// }
// }
// };
// //把任务对象交给Thread处理
// Thread thread=new Thread(myRunnable);
// //启动线程
// thread.start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("子线程执行输出:"+i);
}
}
}).start();
for(int i=0;i<10;i++){
System.out.println("主线程执行输出:"+i);
}
}
}
优缺点
优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
缺点:编程多一层对象包装，如果线程有执行结果是不可以直接返回的
方式三:JDK5.0新增：实现Callable,FutureTask接口
前面两个线程创建方式都存在的问题:
1.他们重写的run方法均不能直接返回结果
2.不适合需要返回线程执行结果的业务场景
实现步骤
1.得到任务对象
(1)定义类实现Callable接口，重写call方法，封装要做的事情
(2)用FutureTask把Callable对象封装成线程任务对象
2.把线程任务对象交给Thread对象
3.调用Thread的start方法启动线程，执行任务
4.线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果
实现：
public class ThreadDemo4 {
/**
* 目标:学会线程的创建方式三: 实现Callable接口，结合FutureTask完成
*
* */
public static void main(String[] args) {
//3.创建Callable任务对象
Callable<String> call=new MyCallable(100);
//4.把Callable任务对象，交给FutureTask对象
//FutureTask对象的作用1:是Runnable的对象(实现了Runnable接口),可以交给Thread了
//FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
FutureTask<String> f1=new FutureTask<>(call);
//5.交给线程处理
Thread t1=new Thread(f1);
//启动线程
t1.start();
//获取结果
try {
//如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果
String rs1=f1.get();
System.out.println("第一个结果:"+rs1);
}catch (Exception e) {
e.printStackTrace();
}
}
}
class MyCallable implements Callable<String>{
/**
* 1.定义一个任务类，实现Callable接口 应该声明线程任务执行完毕后的结果的数据类型
* */
private int n;
public MyCallable(int n){
this.n=n;
}
/**
* 重写call方法
* */
@Override
public String call() throws Exception {
int sum=0;
for(int i=1;i<=n;i++){
sum+=i;
}
return "子线程执行的结果是:"+sum;
}
}
优缺点
优点:线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
可以在线程执行完毕后去获取线程执行的结果
缺点：编程复杂
