Java创建线程的三种方式

创建线程的三种方式

先简单说下如何使用，再详细介绍，避免上来就是理论，大家感觉枯燥。学完这章，记得给自己加个鸡腿🍗。

方案一

public class ThreadTest {

    // 继承Thread重写run()方法
   public static class PrimeThread extends Thread {
        public void run() {
            // 业务逻辑
            System.out.println(Thread.currentThread().getName()+" PrimeThread#run()执行成功");
        }
    }

    public static void main(String[] args) {
        PrimeThread thread = new PrimeThread(); //创建线程
        thread.start(); // 启动线程
    }
}

方案一

public class ThreadTest {

    // 实现Runnable重写run()方法
    public static class RunnableTask implements Runnable{
        @Override
        public void run() {
            // 业务逻辑
            System.out.println(Thread.currentThread().getName()+" RunnableTask#run()执行成功");
        }
    }

    public static void main(String[] args) {
        RunnableTask runnableTask = new RunnableTask();
        new Thread(runnableTask).start(); // 启动线程
        new Thread(runnableTask).start(); // 启动线程
    }
}

// 执行结果
Thread-1 RunnableTask#run()执行成功
Thread-0 RunnableTask#run()执行成功

方案三

public class ThreadTest {

    // 实现 Callable 重写call()方法
    public static class CallableTask implements Callable<String> {
        @Override
        public String call() {
            // 业务逻辑
            return Thread.currentThread().getName()+" CallableTask#run()执行成功";
        }
    }

    public static void main(String[] args) {
        CallableTask callableTask = new CallableTask();
        FutureTask<String> futureTask = new FutureTask<>(callableTask); // 创建异步线程
        Thread thread = new Thread(futureTask);
        thread.start(); // 启动线程
        try {
            String result = futureTask.get(); //阻塞，等待结果返回
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

好了，用法讲完，我们讲讲对应的方法。

Thread 线程

基础方法

推荐看：线程状态转换图 juejin.cn/post/690673…

• start(): 线程就绪，等待CPU资源。
• run()：重写该方法，执行业务代码。
• yield()：释放CPU资源，不释放锁资源。
• sleep()：不释放CPU资源，不释放锁资源。
• wait()：释放CPU资源，释放锁资源。
• join()：等待该线程执行结束。

实现Runnable，重写了run()方法。

class Thread implements Runnable{

    /* What will be run. */
    private Runnable target;
    
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

Runnable

@FunctionalInterface
public interface Runnable {
    /**
     * implements 该接口，重写run()方法，
     * 然后创建一个Thread，调用Thread#start()后，该线程在获取到CPU时间片后，就会执行Thread#run()方法。
     */
    public abstract void run();
}

Callable

与Runnable的区别：有返回值。

@FunctionalInterface
public interface Callable<V> {
    
    V call() throws Exception;
}

FutureTask

方案三的执行过程

粗略的画，大家粗略的看，先有个框架。

能看到这都是优秀的孩子！小姐姐的鸡腿就靠你啦！