线程的故事：我的3位母亲成就了优秀的我！

大家好，我是线程，我的英文名叫 Thread，别看我现在风光无限，好像人尽皆知的样子，然而我的身世却悲惨离奇。

十多年的德保网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。营销型网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整德保建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联公司从事“德保网站设计”,“德保网站推广”以来，每个客户项目都认真落实执行。

我出身在一个小山村，那是一个与世隔绝的世外桃源，然而年纪轻轻的我，却展现出了与众不同的性格。比如：当身边的同龄人还在沉浸于玩泥巴的喜悦时，我就开始思考如何避免下雨天对出行造成的阻碍?当身边的同龄人还在沉浸于夕阳下的奔跑时，我已经开始思考为什么太阳会东升西落?而我们人类又为什么会生存在地球上?于此可见一斑。

当时的我在所有人眼里就是一个“怪人”，村里面的阿猫、阿狗走路都要躲着我。但我的母亲懂我，她知道这个小伙子器宇不凡、骨骼惊奇，必是练武奇才，将来保护宇宙的重任和维护世界和平的重任可能要交付与我这个神童身上了，于是在我刚满 3 岁那天，母亲就把我过继给了她的一位远房亲戚了。

首位母亲：继承Thread

接下来我要把我的出生过程演示给你看，这也是我的第一段人生经历。

创建方式一

线程最原始的创建方式，只需要继承 Thread 类，重写 run() 方法即可，实现代码如下：

 
 
 
 
      
  
  
  
  1. // 创建方式 1：继承 Thread 
    2.   
  
  
  
  2. class MyThread extends Thread { 
    3.   
  
  
  
  3.     @Override 
    4.   
  
  
  
  4.     public void run() { 
    5.   
  
  
  
  5.         System.out.println("你好，线程~"); 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8. // 测试 
    9.   
  
  
  
  9. public class ThreadExample { 
    10.   
  
  
  
  10.     public static void main(String[] args) { 
    11.   
  
  
  
  11.         // 创建线程 
    12.   
  
  
  
  12.         Thread thread = new MyThread(); 
    13.   
  
  
  
  13.         // 启动线程 
    14.   
  
  
  
  14.         thread.start(); 
    15.   
  
  
  
  15.     } 
    16.   
  
  
  
  16. } 
    17.

变种方法

以上创建线程的方式略显繁琐，我们也可以使用匿名对象的方式，在创建 Thread 类的时候就直接重写 run() 方法，实现代码如下：

 
 
 
 
      
  
  
  
  1. // 变种 1：匿名方式创建线程 
    2.   
  
  
  
  2. Thread t1 = new Thread() { 
    3.   
  
  
  
  3.     @Override 
    4.   
  
  
  
  4.     public void run() { 
    5.   
  
  
  
  5.         System.out.println("线程变种"); 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. }; 
    8.   
  
  
  
  8. // 启动线程 
    9.   
  
  
  
  9. t1.start(); 
    10.

继承Thread的缺点

Java 语言的设计是单继承，所以当继承了 Thread 之后，就不能再继承其他类了。

也就是说，如果我一直呆在亲生母亲(extends Thread)的身边，那么就得不到好的教育，所以长大之后也注定会普普通通，这可能就是母亲把我过继给远房亲戚的原因吧。

第二位母亲：实现Runnable

在 Java 语言中，虽然不能实现多继承，但可以实现多接口，所以我在第二位母亲家，过得也算如鱼得水。

创建方式二

和继承 Thread 类差不多，实现 Runnable 接口也是重写 run() 方法，具体实现代码如下：

 
 
 
 
      
  
  
  
  1. public class ThreadExample2 { 
    2.   
  
  
  
  2.     // 创建方式 2：实现 Runnable 接口 
    3.   
  
  
  
  3.     static class MyThread implements Runnable { 
    4.   
  
  
  
  4.         @Override 
    5.   
  
  
  
  5.         public void run() { 
    6.   
  
  
  
  6.             System.out.println("你好，线程~"); 
    7.   
  
  
  
  7.         } 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.     // 代码测试 
    10.   
  
  
  
  10.     public static void main(String[] args) { 
    11.   
  
  
  
  11.         // 创建 Runnable 子类 
    12.   
  
  
  
  12.         MyThread myThread = new MyThread(); 
    13.   
  
  
  
  13.         // 创建线程 
    14.   
  
  
  
  14.         Thread thread = new Thread(myThread); 
    15.   
  
  
  
  15.         // 启动线程 
    16.   
  
  
  
  16.         thread.start(); 
    17.   
  
  
  
  17.     } 
    18.   
  
  
  
  18. } 
    19.

变种方法1：匿名Runnable

以上实现 Runnable 的接口有更简单的实现方法，我们可以使用匿名 Runnable 来创建一个线程，如下代码所示：

 
 
 
 
      
  
  
  
  1. // 变种 1：匿名 Runnable 方式 
    2.   
  
  
  
  2. Thread t2 = new Thread(new Runnable() { 
    3.   
  
  
  
  3.     @Override 
    4.   
  
  
  
  4.     public void run() { 
    5.   
  
  
  
  5.         System.out.println("我是线程变种方法~"); 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. }); 
    8.   
  
  
  
  8. // 启动线程 
    9.   
  
  
  
  9. t2.start(); 
    10.

变种方法2：Lambda创建Runnable

在 JDK 8 之后，我们可以使用 Lambda 表达式来操作代码了，所以对于创建匿名 Runnable 类，我们也有了更简单的实现方法，如下代码所示：

 
 
 
 
      
  
  
  
  1. // 变种 2：使用 Lambda 匿名 Runnable 方式 
    2.   
  
  
  
  2. Thread t3 = new Thread(() -> { 
    3.   
  
  
  
  3.     System.out.println("我是变种 2~"); 
    4.   
  
  
  
  4. }); 
    5.   
  
  
  
  5. // 启动线程 
    6.   
  
  
  
  6. t3.start(); 
    7.

注意：以上实现代码只支持 JDK 1.8+ 版本。

第三位母亲：村里的首富

虽然我的前两位母亲对我都很好，但对于我这样一个气宇轩扬、骨骼惊奇将来要拯救宇宙和维护世界和平的少年来说，只在国内混未免局限性太大，所以我一直想去大洋彼岸追寻自己的梦想，然而以「前两位」母亲的财力不足以支撑我这样做。

然而我的第二个家庭和村里的首富一家是至交，得知我的志向之后，他们一家愿意倾囊相授，举一家之力帮我去大洋彼岸追寻我的梦想。于是在感激之余，我的第二位母亲让我当场认下首富一家为我的干爹、干妈。就这样，我就有了第三位母亲了。

创建方式三

前两种创建方式虽然不错，但都不能接收线程执行之后的返回值，于是在 JDK 1.5 之后就加入了 Callable 和 Futrue，用于接收线程执行之后的返回值，具体的实现代码如下：

 
 
 
 
      
  
  
  
  1. import java.util.Random; 
    2.   
  
  
  
  2. import java.util.concurrent.Callable; 
    3.   
  
  
  
  3. import java.util.concurrent.ExecutionException; 
    4.   
  
  
  
  4. import java.util.concurrent.FutureTask; 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. /** 
    7.   
  
  
  
  7.  * 线程创建示例 3 
    8.   
  
  
  
  8.  */ 
    9.   
  
  
  
  9. public class CreateThreadExample3 { 
    10.   
  
  
  
  10.     // 创建方式 3：实现 Callable 接口 
    11.   
  
  
  
  11.     static class MyCallable implements Callable { 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         @Override 
    14.   
  
  
  
  14.         public Integer call() throws Exception { 
    15.   
  
  
  
  15.             int num = new Random().nextInt(10); 
    16.   
  
  
  
  16.             System.out.println("生成随机数：" + num); 
    17.   
  
  
  
  17.             return num; 
    18.   
  
  
  
  18.         } 
    19.   
  
  
  
  19.     } 
    20.   
  
  
  
  20.     // 代码测试 
    21.   
  
  
  
  21.     public static void main(String[] args) throws ExecutionException, InterruptedException { 
    22.   
  
  
  
  22.         // 创建 Callable 子对象 
    23.   
  
  
  
  23.         MyCallable callable = new MyCallable(); 
    24.   
  
  
  
  24.         // 使用 FutureTask 配合 Callable 子对象得到执行结果 
    25.   
  
  
  
  25.         FutureTask futureTask = new FutureTask<>(callable); 
    26.   
  
  
  
  26.         // 创建线程 
    27.   
  
  
  
  27.         Thread thread = new Thread(futureTask); 
    28.   
  
  
  
  28.         // 启动线程 
    29.   
  
  
  
  29.         thread.start(); 
    30.   
  
  
  
  30.         // 得到线程执行的结果 
    31.   
  
  
  
  31.         int result = futureTask.get(); 
    32.   
  
  
  
  32.         System.out.println("主线程中拿到子线程执行结果：" + result); 
    33.   
  
  
  
  33.     } 
    34.   
  
  
  
  34. } 
    35.

以上代码的执行结果如下：

从以上结果可以看出，使用 Callable 配合 FutrueTask 可以正确拿到线程执行之后的返回值。而我的故事也在这里结束了，我最终不负三位母亲所望，虽不能拯救宇宙和维护世界和平，但却也能在程序界作出自己的一些贡献，这就是我和我三位母亲的故事。

总结

本文使用第一人称“我”(Thread)的视角讲了线程创建的三种方式，第一种是继承 Thread，但因为 Java 语言不允许多继承，所以当继承了 Thread 之后就不能继承其他类了，于是就有了第二种方式实现 Runnable 接口的方式。然而前两种实现虽然可以创建线程，但不能接收线程执行之后的返回值，于是就有了第三种实现 Callable，通过它我们可以取得线程执行之后的返回值。

名称栏目：线程的故事：我的3位母亲成就了优秀的我！
新闻来源：http://www.shufengxianlan.com/qtweb/news44/134244.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

建站公司知识

分类信息网

雅安电信机房　　 　成都网站建设　　 　成都网站推广　　 　乐山网站建设　　 　香港云服务器租用　　 　网站设计公司　　 　腾讯云免备案主机　　 　香港四川國際商會　　 　软文发布平台　　 　石膏隔墙　　 　什邡做网站　　 　成都口碑营销公司　　 　成都做网站　　 　成都微商城开发　　 　成都企业网站设计　　 　成都网页设计　　 　成都能净科技　　 　成都酒店服定制　　 　网创优客　　 　成都网站维护