Java 多线程四种实现方式（新手必看）

实现方式一
实现 Runnable 接口，重写run方法

package com.linlijun.test;

public class MultiThreadOne implements Runnable{
     
    @Override
    public void run() {
     
        System.out.println("创建线程成功");
    }
}

把实现类传入 thread 构造方法中，调用start 方法，创建线程

package com.linlijun;

import com.linlijun.test.MultiThreadOne;

public class Main {
     

    public static void main(String[] args) {
     
        MultiThreadOne multiThreadOne = new MultiThreadOne();
        Thread thread = new Thread(multiThreadOne);
        thread.start();
    }
}

实现方式二
直接继承thread类，重写run方法，直接调用start方法，创建线程

package com.linlijun.test;

public class MultiThreadTwo extends Thread{
     
    @Override
    public void run() {
     
        System.out.println("使用继承thread方式");
    }
}

创建 MultiThreadTwo 对象，直接调用start方法

package com.linlijun;

import com.linlijun.test.MultiThreadOne;
import com.linlijun.test.MultiThreadTwo;

public class Main {
     

    public static void main(String[] args) {
     
        MultiThreadTwo multiThreadTwo = new MultiThreadTwo();
        multiThreadTwo.start();
    }
}

实现方式三
实现Callable接口，重写call方法，JDK1.5新增，可以有返回值

package com.linlijun.test;

import java.util.concurrent.Callable;

public class MultiThreadThree implements Callable {
     
    @Override
    public Object call() throws Exception {
     
        System.out.println("我是实现了Callabel接口的");
        // 在这里设置返回值
        return "返回值";
    }
}

创建Callable对象传入FutureTash构造方法，再把FutureTask对象传入
Thread构造方法

package com.linlijun;

import com.linlijun.test.MultiThreadOne;
import com.linlijun.test.MultiThreadThree;
import com.linlijun.test.MultiThreadTwo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Main {
     

    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        MultiThreadThree multiThreadThree = new MultiThreadThree();
        // 把实现了Callable 接口的实现类 先传入 FutureTask 的构造方法
        FutureTask futureTask = new FutureTask(multiThreadThree);
        // 把 FutureTask对象传入Thread的构造方法中
        Thread thread = new Thread(futureTask);
        // 开启线程
        thread.start();
        // 获得返回值
        Object o = futureTask.get();
        String result = (String)o;
        System.out.println(result);

    }
}

实现方法四
使用Executors创建线程池，使用ExecutorService的execute方法和
submit方法开启线程

package com.linlijun;

import java.util.concurrent.*;

public class Main {
     

    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.execute(new Runnable() {
     
            @Override
            public void run() {
     
                System.out.println("不带返回值：executors方法方式实现多线程");
            }
        });
        // 这里是演示我传入匿名内部类。要有具体的返回值，还是需要传入实现Callable的实现类进去
      Future future =   executorService.submit(new Runnable() {
     
            @Override
            public void run() {
     
                System.out.println("带返回值：executors方法方式实现多线程");
            }
        });

    }
}

上述四种实现方式优点
接口方式（实现Runnabel、Callable接口）：通过接口方式实现更有灵活性，Java只能是单继承，但可以多实现。
继承Thread 类：具有单继承的缺点，灵活性相对比较低，当时实现简单，代码清晰
线程池方式（Executors）: 使用线程池是绝大多数框架使用的方式，避免频繁创建销毁连接（频繁创建和销毁连接是非常消耗性能的操作，在实际项目中要尽量避免）。这种方式是实际中用的得比较多的

到这里多线程的几种方法我已经给出了。如果对你有帮助，麻烦给个赞咯。谢谢。下一篇我准备对多线程几种实现方法优劣和里面几个重要方法进行讲解。
如果对我感兴趣，或者想在手机上看我的文章：请关注我的公众号（微信搜：Linlj_gzh）