[Java知识库]Java 多线程编程 Java实现多线程的三种方式

三种创建方式
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

步骤：
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);