1、多线程-线程实现的4种方式

一、线程简介

1、概念：多线程指的是多条路径同时执行。多个任务是开启多线程的初衷

二、线程实现

1、继承Thread类，重写run方法，调用start方法启动线程。Thread类在java.lang包下。

package com.hello;

/**
 * 创建线程方式一
 * 1、创建：继续Thread，重写run方法
 * 2、启动：创建子类对象，调用start方法
 */
public class StartThread extends Thread {

    /**
     * 线程入口点
     */
    @Override
    public void run() {
        for(int i=0; i<5; i++){
            System.out.println("一边听歌");
        }
    }

    public static void main(String[] args) {
        StartThread st = new StartThread();
        st.start(); // 开启一个线程，不保证立即运行，由cpu调用
//      st.run(); // 普通方法调用

        for(int i=0; i<5; i++){
            System.out.println("一边coding");
        }
    }
}

2、实现Runnable接口，重写run方法，通过new.Thread调用start方法。Runnable接口在java.lang包下。

package com.hello;

/**
 * 创建线程方式二
 * 1、创建：实现Runnable，重写run方法
 * 2、启动：创建实现类对象，创建代理类对象，调用start方法
 *
 * 推荐：避免单继承的局限性，优先使用接口，方便共享资源
 */
public class StartRunnable implements Runnable {

    /**
     * 线程入口点
     */
    @Override
    public void run() {
        for(int i=0; i<5; i++){
            System.out.println("一边听歌");
        }
    }

    public static void main(String[] args) {
        // 创建实现类对象
        StartRunnable sr = new StartRunnable();
        // 创建代理类对象
        Thread t = new Thread(sr);
        t.start(); // 开启一个线程，不保证立即运行，由cpu调用

        for(int i=0; i<5; i++){
            System.out.println("一边coding");
        }
    }
}

3、实现Callable接口，重写call方法。Callable接口在java.util.concurrent并发包下。

package com.hello;

import java.util.concurrent.*;

/**
 * 创建线程方式三
 * 1、实现Callable接口，重写call方法
 *
 * 模拟龟兔赛跑
 *
 */
public class RacerCallable implements Callable<Integer> {
    private String winner;// 胜利者

    @Override
    public Integer call() throws InterruptedException {

        for (int step=1; step<=100; step++) {
            // 模拟兔子睡觉
            if (Thread.currentThread().getName().equals("pool-1-thread-1") && step%10==0) {
                Thread.sleep(100);
            }
            System.out.println(Thread.currentThread().getName()+"--->"+step);
            boolean flag = gameOver(step); // 判断比赛是否结束
            if (flag){
                return step;
            }
        }
        return null;
    }

    public boolean gameOver(int step) {
        if (winner != null) { // 判断是否有胜利者
            return true;
        } else {
            if (step == 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner is===>" + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        RacerCallable r = new RacerCallable();

        // 创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(2);

        // 提交执行
        Future<Integer> result1 = service.submit(r);
        Future<Integer> result2 = service.submit(r);

        // 获取结果
        Integer r1 = result1.get();
        Integer r2 = result2.get();
        System.out.println(r1 + "--->" + r2);

        // 关闭服务
        service.shutdownNow();
    }
}

4、CompletableFuture实现异步操作，java.util.concurrent并发包下。

import java.util.concurrent.*;

public class CompletableFutureTest {

    private static final Executor executor = Executors.newFixedThreadPool(100,
            (Runnable r) -> {
                Thread t = new Thread(r);
                t.setDaemon(true);//使用守护线程，这种方式不会阻止程序的关停
                return t;
            }
    );

    public static void main(String[] args) {
        CompletableFuture<String> f = CompletableFuture.supplyAsync(() -> {
            return test();
        }, executor);

        System.out.println("test1");

        try {
            f.get(3, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }

        System.out.println("test3");
    }

    public static String test() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2");
        return "ok";
    }
}