线程专区---第1集实现线程的5种方式

1 通过继承线程类的方式

/**
 * 通过继承Thread方法去实现线程
 */
public class Main1 {
    public static void main(String[] args) {
       new MyThread1().start();
    }
}


class MyThread1 extends Thread {
    public void run() {
        System.out.println("我是通过继承Thread的方式重新run方法实现的");
    }
}

2 通过实现 Runnable的方式实现线程

/**
 * 通过实现 Runnable的方式实现线程
 */
public class Main2 {
    public static void main(String[] args) {
        new Thread(new MyRunnable()).start();
    }
}

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("我实现了Runnable接口,正在执行重写的方法run(),");
    }
}

 

 

3 通过实现Callable自定义myCallable类作为构造参数 创建出一个 FutureTask 的方式实现

package mythread.第1集实现线程的5种方式;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 通过实现Callable自定义myCallable类作为构造参数 创建出一个 FutureTask 的方式实现
 */
public class Main3 {
    public static void main(String[] args) {
        //创建一个Callable 对象
        Callable<String> myCallable = new MyCallable<String>();
        // 根据 Callable 创建一个 FutureTask
        FutureTask<String> oneTask = new FutureTask<String>(myCallable);
        // 执行线程
        new Thread(oneTask).start();
    }
}

class MyCallable<V> implements Callable<V> {

    @Override
    public V call() throws Exception {
        System.out.println("我实现了Callable接口，我正在执行call（）方法");
        return null;
    }
}

 

4 通过线程池的方式创建

package mythread.第1集实现线程的5种方式;

import java.util.concurrent.*;

/**
 * 通过线程池的方式创建
 */
public class Main4 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        a1();
        a2();
    }

    public static void a1() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是通过线程池的方式执行的线程方法(Runnable)（java8之前的）");
            }
        });
        executorService.submit(() -> {
            System.out.println("我是通过线程池的方式执行的线程方法(Runnable)（java8之后的）");
        });
    }

    public static void a2() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        Future<String> future1 = executorService.submit(() -> {
            return "我是通过线程池的方式执行的线程方法(Callable)（java8之后的）";
        });
        System.out.println(future1.get());
        Future<String> future2 = executorService.submit(new Callable<String>() {
            @Override
            public String call() {
                return "我是通过线程池的方式执行的线程方法(Callable)（java8之后的)";
            }
        });
        System.out.println(future2.get());
    }
}

 

5 通过 @Async + Future 的方式

package mythread.第1集实现线程的5种方式;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;

import java.util.concurrent.Future;

/**
 * 注意：下面的run（）方法不是异步的，因为没有配置注解和配置（如有兴趣请自己搜索  springboot @Async + Future ）
 */
public class Main5 {
    public static void main(String[] args) throws Exception {
        FutureDemo futureDemo=new FutureDemo();
        for (int i=0;i<1000;i++){
           Future<String>future= futureDemo.run(i);
            System.out.println(future.get());
        }
    }
}


class FutureDemo{
    @Async("FutureExecutor")
    public Future<String> run(int i) throws Exception {
        return new AsyncResult<>("test:"+ i);
    }
}