Java线程创建的两种方法

最新推荐文章于 2024-08-30 18:40:43 发布
最新推荐文章于 2024-08-30 18:40:43 发布
阅读量562 收藏
点赞数
分类专栏： Java线程创建的两种方法 文章标签： java 线程 thread

引自：http://supportopensource.iteye.com/blog/771786 （有修改）


在Java中创建线程有两种方法：继承Thread类和实现Runnable接口。 


一、继承Thread类创建线程类（Thread类已经实现了Runnable接口）  

1、Thread类的构造方法有8个，但常用的只有4个，分别为： 
 
Thread类中的两个最主要的方法： 
（1）run()—包含线程运行时所执行的代码，即线程需要完成的任务，是线程执行体。 
（2）start()—用于启动线程。 

2、通过继承Thread类来创建并启动多线程的步骤： 
（1）定义Thread类的子类，并覆盖该类的run()方法。 
（2）创建Thread子类的实例，即创建线程对象。 
（3）用线程对象的start()方法来启动该线程。 
例程1： 
Java代码   收藏代码
  1. public class Thread1 extends Thread{  
  2.     public void run(){  
  3.         System.out.println(this.getName());  
  4.     }  
  5.     public static void main(String args[]){  
  6.         System.out.println(Thread.currentThread().getName());  
  7.         Thread1 thread1 = new Thread1();  
  8.         Thread1 thread2 = new Thread1();  
  9.         thread1.start();  
  10.         thread2.start();  
  11.     }  
  12. }  


程序的运行结果如下： 
main 
Thread-0 
Thread-1  

注意：程序中两条线程并发执行时，每次的执行结果是会变化的。这是因为，如果多个没有同步约束关系的线程并发执行时，调度线程将不能保证哪个线程先执行及其持续的时间，在不同平台上，或在同一平台上不同时刻的多次运行可能会得到不同的结果。 
Java中对于线程启动后唯一的能够保障的就是：“每个线程都将启动，每个线程都会执行结束”。但谁会先执行谁会后执行，将没有保障，也就是说，就算一个线程在另一个线程之前启动，也无法保障该线程一定在另一个线程之前执行完毕。  

程序分析如下：  
（1）任何一个Java程序都必须有一个主线程。主线程的线程执行体不是由run()方法来确定的，而是由main()方法来确定的：main()方法的方法体代表主线程的线程执行体。 
（1）上面程序用到线程的两个方法： 
Thread.currentThread()：currentThread()是Thread类的静态方法，该方法总是返回当前正在执行的线程对象的引用。 
getName()：该方法是Thread类的实例方法，该方法返回调用该方法的线程的名字。 
（3）程序可以通过setName(String name)方法为线程设置名字，也可以通过getName()方法返回指定线程的名字。在默认情况下，主线程的名字为main，用户启动的多条线程的名字依次为：Thread-0、Thread-1、Thread-2、……、Thread-n等。 
（4）一个线程只能被启动一次。否则会抛出java.lang.IllegalThreadStateException异常。 


例程2： 
Java代码   收藏代码
  1. public class TestThread1{  
  2.     public static void main(String args[]){  
  3.         Thread t1 = new Thread3();  
  4.         Thread t2 = new Thread3();  
  5.         t1.start();  
  6.         t2.start();  
  7.     }  
  8. }  
  9. class Thread3 extends Thread{  
  10.     public void run(){  
  11.         for(int i=0;i<10;i++){  
  12.             System.out.println(this.getName()+":"+i);  
  13.         }  
  14.     }  
  15. }  


程序的运行结果如下： 
Thread-0:0 
Thread-0:1 
Thread-1:0 
Thread-0:2 
Thread-0:3 
Thread-0:4 
Thread-1:1 
Thread-0:5 
Thread-0:6 
Thread-1:2 
Thread-0:7 
Thread-1:3 
Thread-0:8 
Thread-1:4 
Thread-0:9 
Thread-1:5 
Thread-1:6 
Thread-1:7 
Thread-1:8 
Thread-1:9  

例程4： 
Java代码   收藏代码
  1. public class FirstThread extends Thread{  
  2.     private int i;  
  3.     public void run(){  
  4.         for(;i<10;i++){  
  5.             System.out.println(this.getName()+":"+i);  
  6.         }  
  7.     }  
  8.     public static void main(String args[]){  
  9.         for(int i=0;i<10;i++){  
  10.             System.out.println(Thread.currentThread().getName()+":"+i);  
  11.             if(i==5){  
  12.                 new FirstThread().start();  
  13.                 new FirstThread().start();  
  14.             }  
  15.         }  
  16.     }  
  17. }  


程序的运行结果如下： 
main:0 
main:1 
main:2 
main:3 
main:4 
main:5 
Thread-0:0 
Thread-0:1 
Thread-0:2 
Thread-1:0 
main:6 
main:7 
Thread-1:1 
Thread-1:2 
Thread-0:3 
Thread-1:3 
main:8 
Thread-1:4 
Thread-0:4 
Thread-0:5 
Thread-1:5 
main:9 
Thread-1:6 
Thread-1:7 
Thread-0:6 
Thread-1:8 
Thread-0:7 
Thread-1:9 
Thread-0:8 
Thread-0:9  

结果分析：  
从以上结果可以看出：Thread-0和Thread-1两条线程各自都会输出的i变量，比如存在Thread-0:5和Thread-1:5，因为i是FirstThread类的实例变量，而不是局部变量，而每次创建线程对象都需要创建一个FirstThread对象，所以Thread-0和Thread-1不能共享该实例属性。因而可以得出以下结论： 使用继承Thread类的方法来创建线程类，多条线程之间无法共享线程类的实例变量 。 


二、实现Runnable接口创建线程类  

实现Runnable接口的类必须使用Thread类的实例才能创建线程。通过实现Runnable接口来创建并启动多线程的步骤： 
（1）定义Runnable接口的实现类，并实现该接口的run()方法。 
（2）创建Runnable实现类的实例，然后将该实例作为参数传入Thread类的构造方法来创建Thread对象。 
（3）用线程对象的start()方法来启动该线程。 
例程5： 
Java代码   收藏代码
  1. public class MyRunnable implements Runnable{  
  2.     public void run(){  
  3.         System.out.println(Thread.currentThread().getName());  
  4.     }  
  5.     public static void main(String args[]){  
  6.         MyRunnable r1 = new MyRunnable();  
  7.         MyRunnable r2 = new MyRunnable();  
  8.         MyRunnable r3 = new MyRunnable();  
  9.         Thread thread1 = new Thread(r1,"MyThread1");  
  10.         Thread thread2 = new Thread(r2);  
  11.         thread2.setName("MyThread2");  
  12.         Thread thread3 = new Thread(r3);  
  13.         thread1.start();  
  14.         thread2.start();  
  15.         thread3.start();  
  16.     }  
  17. }  


程序的运行结果如下： 
MyThread1 
MyThread2 
Thread-1  

当然，实现Runnable接口的类的对象可以被同时传给多个线程对象。上述程序修改如下： 
Java代码   收藏代码
  1. MyRunnable r1 = new MyRunnable();  
  2. Thread thread1 = new Thread(r1,"MyThread1");  
  3. Thread thread2 = new Thread(r1);  
  4. thread2.setName("MyThread2");  
  5. Thread thread3 = new Thread(r1);  
  6. thread1.start();  
  7. thread2.start();  
  8. thread3.start();  

运行的结果是类似的。 

例程6： 
Java代码   收藏代码
  1. public class TestThread2{  
  2.     public static void main(String args[]){  
  3.         Runnable1 r1 = new Runnable1();  
  4.         Thread t1 = new Thread(r1);  
  5.         Thread t2 = new Thread(r1);  
  6.         t1.start();  
  7.         t2.start();  
  8.     }     
  9. }  
  10. class Runnable1 implements Runnable{  
  11.     public void run(){  
  12.         for(int i=0;i<10;i++){  
  13.             System.out.println(Thread.currentThread().getName()+":"+i);  
  14.         }  
  15.     }  
  16. }  


程序的运行结果如下： 
Thread-1:0
Thread-0:0
Thread-1:1
Thread-0:1
Thread-1:2
Thread-0:2
Thread-0:3
Thread-0:4
Thread-1:3
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-1:4
Thread-0:9
Thread-1:5
Thread-1:6
Thread-1:7
Thread-1:8
Thread-1:9
例程7： 
Java代码   收藏代码
  1. public class SecondThread implements Runnable{  
  2.     private int i;  
  3.     public void run(){  
  4.         for(;i<10;i++){  
  5.             System.out.println(Thread.currentThread().getName()+":"+i);  
  6.         }  
  7.     }  
  8.     public static void main(String args[]){  
  9.         for(int i=0;i<10;i++){  
  10.             System.out.println(Thread.currentThread().getName()+":"+i);  
  11.             if(i==5){  
  12.                 SecondThread st = new SecondThread();  
  13.                 new Thread(st,"新线程1").start();  
  14.                 new Thread(st,"新线程2").start();  
  15.             }  
  16.         }  
  17.     }  


程序的运行结果如下： 
main:0
main:1
main:2
main:3
main:4
main:5
新线程1:0
新线程1:1
新线程1:2
新线程1:3
新线程1:4
新线程1:5
新线程1:6
main:6
新线程1:7
main:7
新线程1:8
新线程1:9
main:8
main:9

结果分析：  
从以上结果可以看出：新线程1和新线程2共享一个SecondThread对象，因此在执行run()方法时两个线程对象操纵的是同一个实例变量i。所以在执行输出的变量i的值是惟一的，例如新线程2:3、新线程1:2、新线程2:4，不会再出现新线程1:3或者新线程2:1等，且i值在逻辑上也是连续的，即i会从1到9由新线程1和新线程2交替惟一地输出，而实际顺序会不连续。因而可以得出以下结： 采用实现Runnable接口的方法来创建线程类，多条线程可以共享同一个线程类（Runnable接口的实现类即target类）的实例属性。  

注意：在使用继承Thread类时获得当前线程对象直接使用this就可以了，但是实现Runnable接口时要获得当前线程对象必须使用Thread.currentThread()方法。  

若对上述程序作如下修改： 
Java代码   收藏代码
  1. SecondThread st1 = new SecondThread();  
  2. SecondThread st2 = new SecondThread();  
  3. new Thread(st1,"新线程1").start();  
  4. new Thread(st2,"新线程2").start();  


程序的运行结果如下： 
main:0 
main:1 
main:2 
main:3 
main:4 
main:5 
main:6 
main:7 
新线程1:0 
新线程2:0 
新线程2:1 
新线程1:1 
main:8 
main:9 
新线程1:2 
新线程1:3 
新线程1:4 
新线程2:2 
新线程1:5 
新线程2:3 
新线程1:6 
新线程2:4 
新线程1:7 
新线程2:5 
新线程1:8 
新线程2:6 
新线程1:9 
新线程2:7 
新线程2:8 
新线程2:9  

结果分析：  
从以上结果可以看出：新线程1和新线程2分别操纵不同的SecondThread对象的实例变量。 

记住：Thread类本身也实现了Runnable接口，因此Thread类及其子类的对象也可以作为target传递给新的线程对象。  

三、两种创建线程方式的比较  

采用继承Thread类方式： 
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。 
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。 
采用实现Runnable接口方式： 
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标(target)对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。 
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。 
lxz26192
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程的创建方式
m0_54202121的博客
04-24 2284
7.Callable&Future 接口 ​ 目前我们学习了有两种创建线程的方法-一种是通过创建 Thread 类，另一种是通过使用 Runnable 创建线程。但是，Runnable 缺少的一项功能是，当线程终止时（即 run（）完成时），我们无法使线程返回结果。为了支持此功能， Java 中提供了 Callable 接口。 现在我们学习的是创建线程的第三种方案—Callable 接口 Callable 接口的特点如下(重点) • 为了实现 Runnable，需要实现不返回任何内容的 run（）方
JAVA之创建线程的两种方法
蓝莓味的鱼
05-26 498
前提：1：这两种方法都是通过重写run()，在run()方法中实现运行在线程上的代码2：Runnable相比于Thread更适合多个相同程序代码去处理同一个资源的情况，通常采用Runnable3：被synchronized 修饰的方法在某一时刻只允许一个线程访问继承Thread类创建多线程package rjxy;/* * 通过继承Thread类的方式创建两个线程，在Thread构造方法中指定线程...
线程总结（线程的创建和启动的方法）
骆驼草的家园
12-17 218
转载：http://supportopensource.iteye.com/blog/771786 在Java中创建线程有两种方法：继承Thread类和实现Runnable接口。 一、继承Thread类创建线程类（Thread类已经实现了Runnable接口） 1、Thread类的构造方法有8个，但常用的只有4个，分别为： Thread类中的两个最主要的方法： （1）run()—包含线程...
java中创建线程的三种方法以及区别
weixin_33800593的博客
07-14 364
Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 下面让我们分别来看看这三种创建线程的方法。 ------------------------继承Thread类创建线程-------...
总结:几种创建线程的方法
xiueer
10-19 390
package comm;public class ThreadTest { public static void main(String[] args) { // 1 for (int i = 0; i < 10; i++) { // main主线程 System.out.println(Thread.currentThread().ge
Java创建线程方法
stdio_54456153的博客
09-16 100
一、继承Thread类 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程需要完成的任务。因此把 run() 方法称为线程执行体。 创建 Thread 子类的实例，即创建了线程对象。 调用线程对象的 start() 方法来启动该线程。 示例代码如下： public class ThreadTest extends Thread{ pr...
Java创建线程的两种方式
xiaoweids的博客
08-19 1325
也就是说，接口Runnable可以作为Thread的构造方法的参数，但是因为接口无法实例化创建对象，所以我们要先创建一个实现类实现接口Runnable，再作为参数给Thread。start就相当于线程的启动开关，调用了这个方法，线程才能启动，同时run方法才能运行，不调用start方法，只调用run方法，它是没法运行的。这个方法昨天就接触过，当线程调用这个方法时，线程会启动，同时Java虚拟机会调用此线程的run方法。②的本质就相当于③，③有两个步骤：一是创建类B实现接口A，二是创建该类的对象。
java创建线程的两种方法区别
08-30
本文将通过实例代码对这两种方法进行比较和分析，帮助读者更好地理解 Java 中的线程创建机制。 继承 Thread 类 继承 Thread 类是创建线程的一种方式。通过继承 Thread 类，可以重写 run() 方法，定义线程的执行体...
Java创建子线程的两种方法
08-19
Java 创建子线程的两种方法是 Java 编程中非常重要的知识点。创建子线程的两种方法主要介绍了 Java 创建子线程的两种方法，通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、继承 ...
在Java中创建线程有两种方法
08-05
在Java中创建线程有两种方法：使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此，无论是通过Thread类还是Runnable接口建立线程，都必须建立Thread类或它的子类的实例。
简单了解Java创建线程两种方法
08-25
"Java创建线程两种方法" Java语言中提供了两种创建线程的方法，一种是通过继承Thread类，另一种是通过实现Runnable接口。在本篇文章中，我们将通过示例代码详细介绍这两种方法的实现过程。 1. 通过继承Thread类...
在Java中创建线程有两种方法.doc
06-28
### 在Java中创建线程的两种方法 #### 一、概述 在Java中，创建线程主要有两种方式：一种是通过继承`Thread`类来实现；另一种是通过实现`Runnable`接口来完成。这两种方法都能有效地创建并启动线程，但它们各自的...
java创建线程的方式
weixin_42606135的博客
07-10 155
1.继承Thread类创建线程 此方法的缺点是Java是单继承，继承Thread类后无法继承别的类public class ThreadDemo extends Thread{ private List list; public ThreadDemo(List a) { this.list=a; } public void run() { System.out.println("...
JAVA创建线程的方法
blue_mxy的博客
03-02 341
JAVA创建线程的方法1、继承Thread类创建线程2、实现Runnable接口创建线程3、使用Callable和Future创建线程4、使用线程池创建线程使用Executor框架，提供四种线程池1、newCachedThreadPool2、newFixedThreadPool3、newScheduledThreadPool4、newSingleThreadExecutor 1、继承Thread类创建线程 public class ThreaDemo extends Thread{ @Override
Java创建线程的方式
乾坤未定，你我皆是黑马
11-21 696
1.继承Thread类创建线程 继承Thread类，重写run方法，调用start方法启动。 public class MyThread extends Thread{//继承Thread类 　　public void run(){ 　　//重写run方法 　　} } public class Main { 　　public static void main(String[] args){ 　　　　new MyThread().start();//创建并启动线程 　　} } 2.实现Runnable接口创
Java创建线程的方式有哪些
kykangyuky的博客
02-23 260
1.通过继承Thread类创建 定义Thread的子类，重写run()方法 创建子类的实例=》创建线程对象 调用线程对象的start()方法启动线程 public class CreateByThread extends Thread{ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(i); } }
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 3220
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值