实现多线程的4种方式

1. 继承Thread类

1.1 步骤

1. 创建一个类，继承Thread类，该类具备多线程的特征
2. 重写Tread类的run方法，在run方法中定义线程任务
3. 创建Tread类的子类的实例，即创建了线程对象。通过调用该对象的start方法开启一条新线程，调用start方法之后java虚拟机会自动调用该线程的run方法

1.2 示例

/**
 * Description: 多线程1:集成Thread类,重写run方法
 *
 * @author BaiGe
 * @date: 2021/6/9 10:15
 * @Version 1.0
 */
public class MyThread1 extends Thread{

    public void run() {
        System.out.println(this.getName());
    }
}

class TestThread1 {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        myThread1.start();
    }
}

2. 实现Runnable接口

2.1 步骤

1. 创建一个类,实现Runnable接口，并重写run方法，在run方法内定义线程任务
2. 创建Runnable接口实现类的实例
3. 创建一个Thread类对象(参数为Runnable接口的实例对象)，该Thread对象才是真正的线程对象
4. Thread对象的start方法开启一个新的线程

2.2 示例

/**
 * Description:多线程2:实现Runnable接口,重写run方法
 *
 * @author BaiGe
 * @date: 2021/6/9 10:29
 * @Version 1.0
 */
public class MyThread2 implements Runnable {
    @Override
    public void run() {
        //实现 Runnable接口,只能用Thread.currentThread()获取当前线程对象
        System.out.println(Thread.currentThread().getName());
    }
}

class TestMyThread2{
    public static void main(String[] args) {
        MyThread2 myThread2=new MyThread2();
        Thread thread=new Thread(myThread2);
        thread.start();
    }
}

3. 实现Callable接口

3.1步骤

1. 创建一个类实现Callable接口，重写call方法定义线程任务
2. 新建FutureTask类，传入Callable接口实现类，该FutureTask类封装了Callable对象的Call方法的返回值
3. 新建Thread类传入FutureTask对象，使用start方法开启线程
4. 使用FutureTask类的get方法获取返回值

3.2示例

/**
 * Description:多线程3:实现Callable接口,重写call方法(该方法能抛出异常,并且有返回值)
 *
 * @author BaiGe
 * @date: 2021/6/9 10:35
 * @Version 1.0
 */
public class MyThread3 implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return "MyThread3";
    }
}

class TestMyThread3  {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread3 myThread3=new MyThread3();
        //由Callable创建一个FutureTask对象：
        FutureTask task=new FutureTask(myThread3);
        //FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。
        //由FutureTask创建一个Thread对象：
        Thread thread=new Thread(task);
        thread.start();
        //获取返回值
        System.out.println(task.get());
    }
}

4. 使用线程池工具

/**
 * Description:多线程4:通过线程池创建线程
 *
 * @author BaiGe
 * @date: 2021/6/9 11:38
 * @Version 1.0
 */
public class MyThread4 implements Runnable {
    @Override
    public void run() {
        System.out.println("线程池方式创建的线程：" + Thread.currentThread().getName());
    }
}

class TestMyThread4 {
    public static void main(String[] args) {
        //线程数量:5
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            MyThread4 thread = new MyThread4();
            executorService.execute(thread);
        }
        //关闭线程池
        executorService.shutdown();
    }
}

ExecutorService、Callable都是属于Executor框架

Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口

1. public static ExecutorService newFixedThreadPool(int nThreads)
   创建固定数目线程的线程池。
2. public static ExecutorService newCachedThreadPool()
   创建一个可缓存的线程池，调用execute
   将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
3. public static ExecutorService newSingleThreadExecutor()
   创建一个单线程化的Executor。
4. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
   创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
5. ExecutoreService提供了submit()方法
   传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成