多线程的实现方案

目录

方案1：继承Thread类

 方案2：实现Runnable接口的方式进行实现

方案3：利用Callable和Future接口方式实现

---

方案1：继承Thread类

1. 定义一个类MyThread继承Thread类
2. 在MyThread类中重写run( )方法
3. 创建MyThread 类的对象
4. 启动线程

第一步：定义一个类MyThread继承Thread类

package com.java.factory.TheadDemo;

public class MyThread extends Thread{
    //重写Thread中的run方法
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("Thread线程开启了"+i);
        }
    }
}

 第三步：创建MyThread 类的对象

package com.java.factory.TheadDemoText;

import com.java.factory.TheadDemo.MyThread;

public class MyThreadText {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //启动线程
        myThread.start();
    }
}

 方案2：实现Runnable接口的方式进行实现

1. 定义一个类MyRunnable实现Runnable接口
2. 在MyRunnable类中重写run( )方法
3. 创建MyRunnbale类对象
4. 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
5. 启动线程

第一步：定义一个类MyRunnable实现Runnable接口

package com.java.factory.TheadDemo;

public class MyRunnable implements Runnable {
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable线程启动");
        }
    }
}

第三步：创建MyRunnbale类对象

package com.java.factory.TheadDemoText;

import com.java.factory.TheadDemo.MyRunnable;

public class MyRunnableText {
    public static void main(String[] args) {
        //创建参数的对象
        MyRunnable myR = new MyRunnable();
        //创建线程对象，把参数参数传递给线程
        //线程启动，执行的就是参数里面的run方法
        Thread thread = new Thread(myR);
        //启动线程
        thread.start();
    }
}

方案3：利用Callable和Future接口方式实现

1. 定义一个类MyCallable实现Callable接口
2. 在MyCallable类中重写call()方法
3. 创建MyCallable类的对象
4. 创建Futrue的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
5. 创建Thread类的对象，把FutureTask对象作为构造方法的参数
6. 启动线程

第一步：定义一个类MyCallable实现Callable接口

package com.java.factory.TheadDemo;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyCallable饿了");
        }
        //返回值就表示线程运行完毕之后的结果
        return "订外卖！";
    }
}

第三步：创建MyCallable类的对象

package com.java.factory.TheadDemoText;

import com.java.factory.TheadDemo.MyCallable;

import java.util.concurrent.FutureTask;

public class MyCallableText {
    public static void main(String[] args) {
        //创建对象，执行call方法
        MyCallable myCallable = new MyCallable();
        //可以获取线程执行完毕之后的结果，也可以作为参数 传递给 Thread 对象
        FutureTask<String> FT = new FutureTask<>(myCallable);
        //创建线程对象
        Thread thread = new Thread(FT);
        //启动线程
        thread.start();

    }
}