线程的基本使用

ゞ浴缸里的玫瑰 2022-10-16 13:24 153阅读 0赞

上一篇**[多线程的基本概念][Link 1]**

了解完多线程的概念之后，我们先来看一下线程的基本使用。

# Java线程的两种实现方式 #

Java中实现线程的方式有**两种**

1.  继承自Thread类，在子类实现run方法
2.  实现Runnable接口，重写run方法

我们先来简单看看Thread类

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70][]

Thread类实现了Runnable接口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 1][]

Runnable接口中只有一个run方法，实际上，线程的任务就是在run方法中执行的，也就是说我们实际开发过程中就是在run方法里写业务代码。

### 方式一：继承Thread类 ###

public class MyWorkThread extends Thread {
        @Override
        public void run() {
    
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "执行任务。。。" + i);
            }
        }
    }

public class TestJava {
    
        public static void main(String[] args) {
    
            /*创建子线程*/
            MyWorkThread myWorkThread = new MyWorkThread();
            /*启动myWorkThread*/
            myWorkThread.start();
            
            /*主线程打印*/
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "执行任务。。。" + i);
            }
        }
    }

运行结果如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 2][]

一般我们不会使用这种方式去实现多线程，因为这种写法比较死板，定义好的线程只能实现固定的写好的任务。

--------------------

## 方式二：实现Runable接口 ##

package methord2;
    
    public class MyRunnable implements Runnable {
        @Override
        public void run() {
    
            for (int i = 0; i < 100; i++) {
                System.out.println("MyRunnable" + i);
    
            }
        }
    }

package methord2;
    
    public class Test {
        public static void main(String[] args) {
    
            MyRunnable myRunnable = new MyRunnable();
    
            Thread thread = new Thread(myRunnable);
            thread.start();
    
            for (int i = 0; i < 100; i++) {
                System.out.println("main :" + i);
            }
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 3][]

**通过匿名内部类简化代码：**

![20210530171942956.png][]

可以看到 Thread 构造接收的Runnable是个接口，那我们可以使用匿名内部类来简化一下代码，如下：

Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        System.out.println("Runnable" + i);
                    }
                }
            });
    
            thread.start();

**通过Lambda表达式简化代码**

由于Runnable接口中只有一个方法，那我们还可以直接写成Lambda的方式，代码如下

Thread thread = new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Runnable" + i);
                }
            });
    
            thread.start();

这样一来，相比方式一，代码就简洁很多了，而且更加灵活。

Kotlin的写法就更简单了，如下：

fun main() {
    
        /*创建线程并启动*/
        Thread {
            for (i in 1..100) {
                println("${Thread.currentThread().name}=========>${i}")
            }
    
        }.start()
    
    
        /*主线程*/
        for (i in 1..100) {
            println("${Thread.currentThread().name}=========>${i}")
        }
    
    }

#  #

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 4][]

Runnable接口中的run方法是没有返回值的，如果我们想获取线程执行的返回结果，可以使用**Callable**

先看下**Callable接口**，可以看到，Callable接口接收一个泛型，实际执行的方法是**call**方法，且这个方法是有**返回值**的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 5][]

这里总结一下Callable和Runnable的区别：

Runnable：实际执行的是 **run** 方法，**没有返回值**

Callable: 实际执行的是 **call** 方法，**有返回值**

下面我们来看下怎么用：

新建一个类，实现Callable接口，可以指定返回值的类型，并实现call方法。

class MyCallable implements Callable<String> {
    
        @Override
        public String call() throws Exception {
    
            Thread.sleep(1000);
            return "success";
        }
    }

看Thread源码可以看到，Thread构造接收的是Runnable类型的参数

![20210605125107424.png][]

所以，我们不能直接将Callable的实现类直接传进去 , 需要用到 **FutureTask**  包装一下

先来看下 FutureTask 的代码，可以看到 FutureTask 类实现了**RunnableFuture**接口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 6][]

**RunnableFuture** 又继承了 **Runnable** 接口，所以，本质上还是**属于实现Runnable接口的方式**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 7][]

这样一来，我们就可以将FutureTask 类型的对象传给Thread了。

用法如下:

public static void main(String[] args) {
    
            /*创建 Callable 对象*/
            MyCallable callable = new MyCallable();
            /*包装成FutureTask*/
            FutureTask<String> stringFutureTask = new FutureTask<>(callable);
            /*创建线程并开始执行*/
            new Thread(stringFutureTask).start();
    
            System.out.println("线程开始执行");
            try {
                /*拿返回结果*/
                String result = stringFutureTask.get();
                System.out.println("执行完毕 拿到结果");
                System.out.println("result = " + result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
    
            System.out.println("主线程执行");
    
    
        }

下面来看下运行结果：

![20210605130936162.gif][]

可以看到，我们可以拿到执行结果了。需要注意的是，这里调FutureTask的get会**阻塞**住**当前线程**

java 简化写法：

public static void main(String[] args) {
    
            /*创建FutureTask 对象*/
            FutureTask<String> stringFutureTask = new FutureTask<>(() -> {
                Thread.sleep(1000);
                return "success";
            });
    
            /*创建线程并开始执行*/
            new Thread(stringFutureTask).start();
    
            System.out.println("线程开始执行");
            try {
                /*拿返回结果*/
                String result = stringFutureTask.get();
                System.out.println("执行完毕 拿到结果");
                System.out.println("result = " + result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
            System.out.println("主线程执行");
        }

kotlin写法就更简单了，如下：

fun main() {
    
    
        /*创建FutureTask对象*/
        val futureTask = FutureTask {
            Thread.sleep(1000)
            "Success"
        }
    
        /*创建线程执行任务*/
        Thread(futureTask).start()
        /*打印*/
        println("futureTask = ${futureTask.get()}")
    }

好了，本篇文章就是这样

**[线程的状态][Link 2]**

--------------------

**如果你觉得本文对你有帮助，麻烦动动手指顶一下，可以帮助到更多的开发者，如果文中有什么错误的地方，还望指正，转载请注明转自[喻志强的博客][Link 3]，谢谢！**

[Link 1]: https://blog.csdn.net/yuzhiqiang_1993/article/details/117385605?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70]: /images/20221014/4cae8374e3434e6888283b33615743b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 1]: /images/20221014/2e9ef3bd3fc14077a55a8f9c28015f3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 2]: /images/20221014/6e538213ef9945279c3b383c4f280d17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 3]: /images/20221014/e2ae7377fbc5499eb87e10aa6a4c6166.png
[20210530171942956.png]: /images/20221014/d28f505c764641c3be34de888597acd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 4]: /images/20221014/04dc3705444c43a2a7f055af214a5aea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 5]: /images/20221014/cbd7f3bc53f244c9ac80b99e3da6cbe1.png
[20210605125107424.png]: /images/20221014/d8291417ae324f5fa76935681d25b990.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 6]: /images/20221014/b1aa638aa64d4ee99095c95a830dcac6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 7]: /images/20221014/64a23dc65c1947058d8e852ff26aba7b.png
[20210605130936162.gif]: /images/20221014/e4ab23901ec8495cacbb6e1658aef54b.png
[Link 2]: https://yuzhiqiang.blog.csdn.net/article/details/117442794
[Link 3]: https://yuzhiqiang.blog.csdn.net/