创建线程的两种方式区别

- 日理万妓 2022-05-25 02:29 244阅读 0赞

Java提供了线程类Thread来创建多线程的程序。其实，创建线程与创建普通的类的对象的操作是一样的，而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程，有两种方法：

◆需要从Java.lang.Thread类派生一个新的线程类，重载它的run()方法。   
◆实现Runnalbe接口，重载Runnalbe接口中的run()方法。

下面就从几个例子来具体列出两种方式的区别

**第一种方式：****继承Thread类**

实现步骤：

1.自定义类继承Thread

2.覆盖Thread中的run()方法

3.创建该类的对象，调用start()方法，开启线程并调用run方法

简单实例：

**\[java\]** [view plain][] [copy][view plain]

1.  class MyThread extends Thread\{    
2.      public void run()\{    
3.          for (int i = 0; i < 100; i++)\{    
4.              System.out.println("MyThread.run()..."\+i);    
5.          \}   /\*单条线程运行一百次\*/  
6.      \}    
7.  \}    
8.  public class test1\{    
9.      public static void main (String\[\] args)\{    
10.         MyThread a = new MyThread();    
11.         a.start();    
12.         for (int j = 0; j < 100; j++)\{    
13.             System.out.println("test1.main()----"\+j);    
14.         \}    
15.     \}    
16. \}

**第二种方式：实现Runnable接口**

实现步骤:

1.定义一个实现Runnable接口的类

2.覆盖run方法

3.创建该类对象，并以该类对象为参数创建Thread类的对象，从而创建了一个线程

4.调用start方法，开启线程并调用run方法。

简单实例：

**\[java\]** [view plain][] [copy][view plain]

1.  class MyThread implements Runnable\{    
2.      public void run ()\{    
3.          for (int i = 0; i < 50; i++)\{    
4.              System.out.println("MyThread.run()..."\+i);    
5.          \}                       /\*每条线程运行50次，共200次\*/  
6.      \}    
7.  \}    
8.  public class test1\{    
9.      public static void main (String\[\] args)\{    
10.         MyThread a = new MyThread();    
11.         Thread a1 = new Thread(a);    
12.         Thread a2 = new Thread(a);    
13.         Thread a3 = new Thread(a);    
14.         Thread a4 = new Thread(a);    
15.     
16.         a1.start();    
17.         a2.start();    
18.         a3.start();    
19.         a4.start();    
20.     \}    
21. \}

从上面两个例子看，除了多一个步骤外两种方式区别并不大 那么为什么通常都使用第二种方式呢 我们来看第三个例子

**\[java\]** [view plain][] [copy][view plain]

1.  public class test1\{  
2.      public static void main(String \[\] args)\{  
3.          MyThread m=new MyThread();  
4.          Thread t1=new Thread(m,"Thread 1");  
5.          Thread t2=new Thread(m,"Thread 2");  
6.          Thread t3=new Thread(m,"Thread 3");  
7.          t1.start();         /\*共运行一百次，  三条线程哪条抢到资源就运行哪条  \*/  
8.          t2.start();  
9.          t3.start();  
10.     \}  
11. \}  
12. class MyThread implements Runnable\{  
13.     private int i=0;  
14.     public void run()\{  
15.         while(i<100)\{  
16.             i++;  
17.             System.out.println(i+"  MyThread.run "\+Thread.currentThread().getName());  
18.         \}  
19.     \}  
20. \}

**从这个例子我们可以看出，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的。**

**实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。**

**总结：**

采用继承Thread类方式：  
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。  
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。  
采用实现Runnable接口方式：  
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。  
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

[view plain]: https://blog.csdn.net/krito_blog/article/details/54808617#