多线程的创建

今天药忘吃喽~ 2022-11-01 01:35 206阅读 0赞

文章目录

  • 前言
  • 一、线程的创建概述
  • 二、Thread创建线程
    • 1.创建步骤
    • 2.代码实现
  • 三、Runnable创建线程
    • 1.创建步骤
    • 2.代码实现
  • 四、Callable创建线程
    • 1.Callable创建线程的优势
    • 2.代码实现
  • 总结

前言

记得好几年前无VIP下载视频的时候感觉有点慢，后来推出了花钱开了个VIP，不光能看很多专享电影，这下载速度也是哐哐的上去了，当时觉得这VIP开得值，现在学了多线程，以及了解了seek，感觉VIP没有那么高 大 上了，就是没VIP的时候，一个工作一个人做，有了VIP之后一个工作多人工作，这效率就提高了非常之多。话不多说，进入今天的主题多线程的建立方法简绍。

一、线程的创建概述

Runnable 接口用于定义线程的执行体，Runnable 接口仅仅有一个run方法。Thread实现了Runnable接口，但是它的run方法没有实现任何东西，需要在Thead子类中实现线程执行体。

在Java中创建线程的常用方式如下：
1，继承Thread并重写run（）
2、实现Runnable接口
3、实现Callable接口

二、Thread创建线程

1.创建步骤

1、定义子类继承自Thread并重写run方法
2、创建子类实例
3、start方法启动线程

2.代码实现

代码如下（第一个线程）：

  1. public class MyThread1 extends Thread{ 
  2.     @Override
  3.     public void run() {  // 重写Thread的run方法
  4.         String name1 = Thread.currentThread().getName();// 使用Thread.currentThread()自带的getName()
  5.         for(int i = 0;i<50;i++) {  //建立一个测试用的for循环
  6.             System.out.println(name1+"打印"+i); // 输出
  7.         }
  8.     }
  9. }

代码如下（第二个线程）：

  1. public class MyThread2 extends Thread{ 
  2.     @Override
  3.     public void run() { 
  4.         String name2 = Thread.currentThread().getName();
  5.         for(int j = 0;j<50;j++) { 
  6.             System.out.println(name2+"打印"+j);
  7.         }
  8.     }
  9. }

代码如下（测试）：

  1. public class Demo02 { 
  3.     public static void main(String[] args) { 
  4.         MyThread1 thread01 = new MyThread1();// 创建一个MyThread1()对象
  5.         thread01.start();// 启动线程1
  6.         MyThread2 thread02 = new MyThread2();// 创建一个MyThread2()对象
  7.         thread02.start();// 启动线程2
  8.     }
  9. }

代码如下（输出）：

  1. Thread-0打印0
  2. Thread-0打印1
  3. Thread-0打印2
  4. Thread-0打印3
  5. Thread-0打印4
  6. Thread-0打印5
  7. Thread-0打印6
  8. Thread-0打印7
  9. Thread-0打印8
  10. Thread-0打印9
  11. Thread-0打印10
  12. Thread-0打印11
  13. Thread-0打印12
  14. Thread-0打印13
  15. Thread-0打印14
  16. Thread-0打印15
  17. Thread-0打印16
  18. Thread-0打印17
  19. Thread-0打印18
  20. Thread-0打印19
  21. Thread-0打印20
  22. Thread-0打印21
  23. Thread-0打印22
  24. Thread-0打印23
  25. Thread-0打印24
  26. Thread-0打印25
  27. Thread-0打印26
  28. Thread-0打印27
  29. Thread-0打印28
  30. Thread-0打印29
  31. Thread-0打印30
  32. Thread-0打印31
  33. Thread-1打印0
  34. Thread-0打印32
  35. Thread-1打印1
  36. Thread-0打印33
  37. Thread-1打印2
  38. Thread-0打印34
  39. Thread-1打印3
  40. Thread-1打印4
  41. Thread-1打印5
  42. Thread-1打印6
  43. Thread-1打印7
  44. Thread-1打印8
  45. Thread-1打印9
  46. Thread-1打印10
  47. Thread-1打印11
  48. Thread-1打印12
  49. Thread-1打印13
  50. Thread-1打印14
  51. Thread-1打印15
  52. Thread-1打印16
  53. Thread-1打印17
  54. Thread-1打印18
  55. Thread-1打印19
  56. Thread-1打印20
  57. Thread-1打印21
  58. Thread-1打印22
  59. Thread-1打印23
  60. Thread-1打印24
  61. Thread-1打印25
  62. Thread-1打印26
  63. Thread-1打印27
  64. Thread-1打印28
  65. Thread-1打印29
  66. Thread-1打印30
  67. Thread-1打印31
  68. Thread-1打印32
  69. Thread-1打印33
  70. Thread-1打印34
  71. Thread-1打印35
  72. Thread-1打印36
  73. Thread-1打印37
  74. Thread-1打印38
  75. Thread-1打印39
  76. Thread-1打印40
  77. Thread-1打印41
  78. Thread-1打印42
  79. Thread-1打印43
  80. Thread-1打印44
  81. Thread-1打印45
  82. Thread-1打印46
  83. Thread-1打印47
  84. Thread-1打印48
  85. Thread-1打印49
  86. Thread-0打印35
  87. Thread-0打印36
  88. Thread-0打印37
  89. Thread-0打印38
  90. Thread-0打印39
  91. Thread-0打印40
  92. Thread-0打印41
  93. Thread-0打印42
  94. Thread-0打印43
  95. Thread-0打印44
  96. Thread-0打印45
  97. Thread-0打印46
  98. Thread-0打印47
  99. Thread-0打印48
  100. Thread-0打印49

三、Runnable创建线程

1.创建步骤

1、定义Runnable接口的实现类，并重写接口的run（）方法
2、创建Runnable实现类的对象
3、创建Thread类的对象
4、通过start方法启动线程

2.代码实现

代码如下（第一个线程）：

  1. public class MyRunable1 implements Runnable{ 
  3.     @Override
  4.     public void run() { // 实现run()方法
  5.         String name1 = Thread.currentThread().getName();// 获取线程名
  6.         for(int i = 0;i<50;i++) {  //建立一个测试用的for循环
  7.             System.out.println(name1+"打印"+i); // 输出
  8.         }
  9.     }
  10. }

代码如下（第二个线程）：

  1. public class MyRunable2 implements Runnable{ 
  3.     @Override
  4.     public void run() { // 实现run()方法
  5.         String name2 = Thread.currentThread().getName();// 获取线程名
  6.         for(int i = 0;i<50;i++) {  //建立一个测试用的for循环
  7.             System.out.println(name2+"打印"+i); // 输出
  8.         }
  9.     }
  10. }

代码如下（测试）：

  1. public class Demo03 { 
  3.     public static void main(String[] args) { 
  4.         MyRunable1 myRunable1 = new MyRunable1();// 创建一个MyRunable1对象
  5.         Thread thread1 = new Thread(myRunable1); // 创建第一个子线程
  6.         thread1.start();// 启动线程1
  7.         MyRunable2 myRunable2 = new MyRunable2();// 创建一个MyRunable2对象
  8.         Thread thread2 = new Thread(myRunable2); // 创建第二个子线程
  9.         thread2.start();// 启动线程2
  10.     }
  11. }

代码如下（输出）：

  1. Thread-0打印0
  2. Thread-1打印0
  3. Thread-1打印1
  4. Thread-1打印2
  5. Thread-1打印3
  6. Thread-1打印4
  7. Thread-1打印5
  8. Thread-1打印6
  9. Thread-1打印7
  10. Thread-1打印8
  11. Thread-1打印9
  12. Thread-1打印10
  13. Thread-1打印11
  14. Thread-1打印12
  15. Thread-1打印13
  16. Thread-1打印14
  17. Thread-1打印15
  18. Thread-1打印16
  19. Thread-1打印17
  20. Thread-1打印18
  21. Thread-1打印19
  22. Thread-1打印20
  23. Thread-1打印21
  24. Thread-1打印22
  25. Thread-1打印23
  26. Thread-1打印24
  27. Thread-1打印25
  28. Thread-1打印26
  29. Thread-1打印27
  30. Thread-1打印28
  31. Thread-1打印29
  32. Thread-1打印30
  33. Thread-1打印31
  34. Thread-0打印1
  35. Thread-0打印2
  36. Thread-0打印3
  37. Thread-0打印4
  38. Thread-0打印5
  39. Thread-0打印6
  40. Thread-0打印7
  41. Thread-0打印8
  42. Thread-0打印9
  43. Thread-0打印10
  44. Thread-0打印11
  45. Thread-0打印12
  46. Thread-0打印13
  47. Thread-0打印14
  48. Thread-0打印15
  49. Thread-0打印16
  50. Thread-0打印17
  51. Thread-0打印18
  52. Thread-0打印19
  53. Thread-0打印20
  54. Thread-0打印21
  55. Thread-0打印22
  56. Thread-0打印23
  57. Thread-0打印24
  58. Thread-0打印25
  59. Thread-0打印26
  60. Thread-0打印27
  61. Thread-0打印28
  62. Thread-0打印29
  63. Thread-0打印30
  64. Thread-0打印31
  65. Thread-0打印32
  66. Thread-0打印33
  67. Thread-0打印34
  68. Thread-0打印35
  69. Thread-0打印36
  70. Thread-0打印37
  71. Thread-0打印38
  72. Thread-0打印39
  73. Thread-0打印40
  74. Thread-0打印41
  75. Thread-0打印42
  76. Thread-0打印43
  77. Thread-0打印44
  78. Thread-0打印45
  79. Thread-0打印46
  80. Thread-0打印47
  81. Thread-0打印48
  82. Thread-0打印49
  83. Thread-1打印32
  84. Thread-1打印33
  85. Thread-1打印34
  86. Thread-1打印35
  87. Thread-1打印36
  88. Thread-1打印37
  89. Thread-1打印38
  90. Thread-1打印39
  91. Thread-1打印40
  92. Thread-1打印41
  93. Thread-1打印42
  94. Thread-1打印43
  95. Thread-1打印44
  96. Thread-1打印45
  97. Thread-1打印46
  98. Thread-1打印47
  99. Thread-1打印48
  100. Thread-1打印49

四、Callable创建线程

1.Callable创建线程的优势

通过Thread或者Runnable接口实现多线程时需要从写run（）方法，但是此方法没有返回值，但是使用Callable这个接口即可创建线程还可以获取返回值。

2.代码实现

代码如下（第一个线程）：

  1. import java.util.concurrent.Callable;
  3. public class MyCallable implements Callable<Object>{ 
  5.     @Override
  6.     public Object call() throws Exception { 
  7.         String name1 = Thread.currentThread().getName();// 获取线程名
  8.         int i = 0;
  9.         while(i<40) { // 测试的while循环
  10.             System.out.println(name1+"打印"+i); // 输出
  11.             i++;
  12.         }
  13.         return i;
  14.     }
  15. }

代码如下（第二个线程）：

  1. import java.util.concurrent.Callable;
  3. public class MyCallable2 implements Callable<Object>{ 
  5.     @Override
  6.     public Object call() throws Exception { 
  7.         String name2 = Thread.currentThread().getName();// 获取线程名
  8.         int i = 0;
  9.         while(i<40) { // 测试的while循环
  10.             System.out.println(name2+"打印"+i); // 输出
  11.             i++;
  12.         }
  13.         return i;
  14.     }
  15. }

代码如下（测试）：

  1. import java.util.concurrent.ExecutionException;
  2. import java.util.concurrent.FutureTask;
  4. public class Demo04 { 
  6.     public static void main(String[] args) throws InterruptedException, ExecutionException { 
  7.         // 创建第一个子线程
  8.         MyCallable myCallable1 = new MyCallable();
  9.         FutureTask<Object> futureTask1 = new FutureTask<>(myCallable1);
  10.         Thread thread1 = new Thread(futureTask1);
  11.         thread1.start(); // 启动第一个子线程
  12.         // 创建第二个子线程
  13.         MyCallable2 myCallable2 = new MyCallable2();
  14.         FutureTask<Object> futureTask2 = new FutureTask<>(myCallable2);
  15.         Thread thread2 = new Thread(futureTask2);
  16.         thread2.start(); // 启动第二个子线程
  17.         System.out.println("-----华丽的分割线-------");
  18.         // 获取第二个子线程返回的结果
  19.         Object result = futureTask2.get();
  20.         System.out.println("第二个子线程返回的结果为:"+result);
  21.     }
  22. }

代码如下（输出）：

  1. Thread-0打印0
  2. Thread-0打印1
  3. Thread-0打印2
  4. Thread-0打印3
  5. Thread-0打印4
  6. Thread-0打印5
  7. -----华丽的分割线-------
  8. Thread-0打印6
  9. Thread-0打印7
  10. Thread-0打印8
  11. Thread-0打印9
  12. Thread-0打印10
  13. Thread-0打印11
  14. Thread-0打印12
  15. Thread-0打印13
  16. Thread-0打印14
  17. Thread-0打印15
  18. Thread-0打印16
  19. Thread-0打印17
  20. Thread-0打印18
  21. Thread-0打印19
  22. Thread-0打印20
  23. Thread-0打印21
  24. Thread-0打印22
  25. Thread-0打印23
  26. Thread-0打印24
  27. Thread-0打印25
  28. Thread-0打印26
  29. Thread-0打印27
  30. Thread-0打印28
  31. Thread-0打印29
  32. Thread-0打印30
  33. Thread-0打印31
  34. Thread-0打印32
  35. Thread-0打印33
  36. Thread-1打印0
  37. Thread-1打印1
  38. Thread-1打印2
  39. Thread-1打印3
  40. Thread-1打印4
  41. Thread-1打印5
  42. Thread-1打印6
  43. Thread-1打印7
  44. Thread-1打印8
  45. Thread-1打印9
  46. Thread-1打印10
  47. Thread-1打印11
  48. Thread-1打印12
  49. Thread-1打印13
  50. Thread-1打印14
  51. Thread-1打印15
  52. Thread-1打印16
  53. Thread-1打印17
  54. Thread-1打印18
  55. Thread-1打印19
  56. Thread-1打印20
  57. Thread-1打印21
  58. Thread-1打印22
  59. Thread-1打印23
  60. Thread-1打印24
  61. Thread-1打印25
  62. Thread-1打印26
  63. Thread-1打印27
  64. Thread-1打印28
  65. Thread-1打印29
  66. Thread-1打印30
  67. Thread-1打印31
  68. Thread-1打印32
  69. Thread-1打印33
  70. Thread-1打印34
  71. Thread-1打印35
  72. Thread-1打印36
  73. Thread-1打印37
  74. Thread-1打印38
  75. Thread-1打印39
  76. Thread-0打印34
  77. Thread-0打印35
  78. Thread-0打印36
  79. Thread-0打印37
  80. Thread-0打印38
  81. Thread-0打印39
  82. 第二个子线程返回的结果为:40

总结

1、Thread类的run（）方法是一个空方法体，需要在子类中重写run（）方法实现处理逻辑
2、直接调用线程对象的run（）方法，jvm虚拟机不会将其识别为一个新的线程来运行，jvm虚拟机会将其识别成一个普通的方法来调用
3、线程的启动是start（）而不是run（）
4、在子类线程内部可通过Thread.currentThread().getName()来获取线程名
5、可以在测试的时候通过线程对象的getName（）方法获取线程名
6、在同一个进程中，不同线程随机执行，即线程的执行具有随机性（比如上面的三个创建线程的方法测试的不管是for循环还是while循环，循环范围都弄得比较大，就是为了直观体现这一点，这个随机性在线程的学习中一直伴随我们，所以输出篇幅比较大也是这个原因，让大家比较直观的观察出来）

发表评论

表情：
评论列表 （有 0 条评论，206人围观）

还没有评论，来说两句吧...

相关阅读

    相关 【多线程】——Callable创建多线程

        之前小编的博客简单介绍了两种创建线程的方式，随着小编工作过程对这一部分的深入，对这一部分有更深入的理解，也知道其他创建多线程方式，在原来的基础在深入一下！ 回顾

    亦凉亦凉/ 0 赞/ 509 阅读

    相关 多线程的创建

    多任务可以由多进程完成，也可以由一个进程内的多线程完成 进程是由若干线程组成的，一个进程至少有一个线程 启动一个线程就是把一个函数传入并创建`Thread`实例，然后调用`

    短命女短命女/ 0 赞/ 217 阅读

    相关 多线程 线程池的创建

    一简介 线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.

    朱雀朱雀/ 0 赞/ 418 阅读