三种创建方式
1 Thread Class 继承Thread类
2 Runnable接口 实现Runnable接口
3 Callable接口 实现Callable接口
方法一 继承Thread类
步骤：
- 自定义线程类继承Thread类。
- 重写run()方法，编写线程执行体。
- 创建线程对象，调用start()方法启动线程。
注意点：是调用start()方法，而不是run()方法。
举例：
class MyThread1 extends Thread{
private int breakfast=10;
private String name;
public MyThread1(String name){
this.name=name;
}
public void run(){
for(int i =0;i<500;i++){
if(this.breakfast>0){
System.out.println(this.name+"卖早餐---->"+(this.breakfast--));
}
}
}
public static void main(String[] args) {
MyThread1 mt1= new MyThread1("一号窗口");
MyThread1 mt2= new MyThread1("二号窗口");
MyThread1 mt3= new MyThread1("三号窗口");
mt1.start();
mt2.start();
mt3.start();
}
}
方法二 实现Runnable接口
步骤：
- 自定义线程类继承实现Runnable接口。
- 实现run()方法，编写线程执行体。
- 创建线程对象，调用start()方法启动线程。
与 继承Thread类 的区别：参考1
Runnable的实现方式是实现其接口即可；
Thread的实现方式是继承其类；
Runnable接口支持多继承；
Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系，不是同类东西，所以Runnable或Thread本身没有可比性。
推荐：
Runnable接口支持多继承，较为灵活，单个对象可以被多个线程调用，建议平时使用Runnable接口实现多线程。
class MyThread implements Runnable{
private int ticket = 5;
public void run(){
for (int i=0;i<10;i++)
{
if(ticket > 0){
System.out.println("ticket = " + ticket--);
}
}
}
}
public class RunnableDemo{
public static void main(String[] args){
MyThread my = new MyThread();
new Thread(my).start();
new Thread(my).start();
new Thread(my).start();
}
}
方法三 实现Callable接口
步骤：
1.自定义一个类实现java.util.concurrent包下的Callable接口
2.重写call方法
3.将要在线程中执行的代码编写在call方法中
4.创建FutureTask对象
5.将自定义类的对象传入FutureTask构造方法里面
6.创建Thread线程对象
7.将FutureTask对象传入Thread构造方法中
创建Callable的实现类，其中的泛型Integer是call方法的返回值类型：
import java.util.Random;
import java.util.concurrent.Callable;
/**
* 多线程实现的第三种方法，实现Callable接口 优点： 可以获取返回值 可以抛出异常
*/
//1.定义一个类实现Callable<V>接口
public class MyCallable implements Callable<Integer> {
// 2.重写call方法
@Override
public Integer call() throws Exception {
// 3.将要执行的代码写在call方法中
//返回一个随机数
Random r = new Random();
int num = r.nextInt(100);
return num;
}
}
测试类：
MyCallable mc = new MyCallable();
//这里的泛型要跟MyCallable中的泛型一致
FutureTask<Integer> task = new FutureTask<>(mc);
//创建线程对象
Thread t = new Thread(task);
t.start();
//获取线程的运算结果
Integer result = task.get();
System.out.println(result);
lambda写法：
FutureTask<Integer> task = new FutureTask<>(() -> {
Random r = new Random();
int num = r.nextInt(100);
return num;
});
//创建线程对象
Thread t = new Thread(task);
t.start();
//获取线程的运算结果
Integer result = task.get();
System.out.println(result);