线程Thread类的start()方法和run()方法

一、初识

java的线程是通过java.lang.Thread类来实现的。VM启动时会有一个由主方法所定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

在Java当中,线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。

  第一是创建状态。在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。

  第二是就绪状态。当调用了线程对象的start方法之后,该线程就进入了就绪状态,但是此时线程调度程序还没有把该线程设置为当前线程,此时处于就绪状态。在线程运行之后,从等待或者睡眠中回来之后,也会处于就绪状态。

  第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程,此时线程就进入了运行状态,开始运行run函数当中的代码。

  第四是阻塞状态。线程正在运行的时候,被暂停,通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend,wait等方法都可以导致线程阻塞。

  第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后,该线程就会死亡。对于已经死亡的线程,无法再使用start方法令其进入就绪。

二、start()方法

1、为什么需要start方法;它的作用是什么?

start()方法来启动线程,真正实现了多线程运行。
start方法的作用就是将线程由NEW状态,变为RUNABLE状态。当线程创建成功时,线程处于NEW(新建)状态,如果你不调用start( )方法,那么线程永远处于NEW状态。调用start( )后,才会变为RUNABLE状态,线程才可以运行。

2、调用start()方法后,线程是不是马上执行?

线程不是马上执行的;准确来说,调用start( )方法后,线程的状态是“READY(就绪)”状态,而不是“RUNNING(运行中)”状态(关于线程的状态详细。线程要等待CPU调度,不同的JVM有不同的调度算法,线程何时被调度是未知的。因此,start()方法的被调用顺序不能决定线程的执行顺序

注意:
由于在线程的生命周期中,线程的状态由NEW ----> RUNABLE只会发生一次,因此,一个线程只能调用start()方法一次,多次启动一个线程是非法的。特别是当线程已经结束执行后,不能再重新启动。

三、run( )方法

1、run方法又是一个什么样的方法?run方法与start方法有什么关联?

run()方法当作普通方法的方式调用
run( )其实是一个普通方法,只不过当线程调用了start( )方法后,一旦线程被CPU调度,处于运行状态,那么线程才会去调用这个run()方法;

2、run()方法的执行是不是需要线程调用start()方法

上面说了,run()方法是一个普通的对象方法,因此,不需要线程调用start()后才可以调用的。可以线程对象可以随时随地调用run方法。

Example1:


 
 
  1. Thread t1 = new Thread( new MyTask( 1));
  2. Thread t2 = new Thread( new MyTask( 2));
  3. t1.run();
  4. t2.run();

上面的输出结果是固定的:

count的值:1
count的值:2

再看另一个实例:


 
 
  1. Thread t1 = new Thread( new MyTask());
  2. Thread t2 = new Thread( new MyTask());
  3. t1.start();
  4. t2.start();

这个输出结果不是固定的,因为线程的运行没法预测。运行结果可能不一样。

MyTask 类:


 
 
  1. //实现Runnable接口
  2. class MyTask implements Runnable{
  3. int count;
  4. public MyTask(int count) {
  5. this.count=count;
  6. }
  7. @Override
  8. public void run() {
  9. System.out.println( "count的值:"+count);
  10. }
  11. }

Example2:

1、用start方法启动线程


 
 
  1. public class Main {
  2. public static void main(String[] args) {
  3. Thread t1 = new Thread( new T1());
  4. Thread t2 = new Thread( new T2());
  5. t1.start();
  6. t2.start();
  7. }
  8. }
  9. class T1 implements Runnable {
  10. public void run() {
  11. try {
  12. for( int i= 0;i< 10;i++){
  13. System.out.println(i);
  14. Thread.sleep( 100); //模拟耗时任务
  15. }
  16. } catch (InterruptedException e) {
  17. e.printStackTrace();
  18. }
  19. }
  20. }
  21. class T2 implements Runnable {
  22. public void run() {
  23. try {
  24. for( int i= 0;i>- 10;i--){
  25. System.out.println(i);
  26. Thread.sleep( 100); //模拟耗时任务
  27. }
  28. } catch (InterruptedException e) {
  29. e.printStackTrace();
  30. }
  31. }
  32. }

结果:
这里写图片描述
说明两线程是并发执行的。

2、先用run方法启动线程
将上面的start()改为run()


 
 
  1. public class Main {
  2. public static void main(String[] args) {
  3. Thread t1 = new Thread( new T1());
  4. Thread t2 = new Thread( new T2());
  5. t1.run();
  6. t2.run();
  7. }
  8. }

这里写图片描述
说明两线程实际是顺序执行的。

总结:

通过实例1和实例和我们可以知道start方法是用于启动线程的,可以实现并发,而run方法只是一个普通方法,是不能实现并发的,只是在并发执行的时候会调用。

说到这,不知道小伙伴们有没有明白这两个方法的区别,如果还有疑问,可以留言交流。

四、start()方法和run()方法源码解析(基于JDK1.7.0_40)


 
 
  1. public synchronized void start() {
  2. // 如果线程不是"就绪状态",则抛出异常!
  3. if (threadStatus != 0)
  4. throw new IllegalThreadStateException();
  5. // 将线程添加到ThreadGroup中
  6. group. add( this);
  7. boolean started = false;
  8. try {
  9. // 通过start0()启动线程,新线程会调用run()方法
  10. start0();
  11. // 设置started标记=true
  12. started = true;
  13. } finally {
  14. try {
  15. if (!started) {
  16. group.threadStartFailed( this);
  17. }
  18. } catch (Throwable ignore) {
  19. }
  20. }
  21. }

 
 
  1. public void run() {
  2. if (target != null) {
  3. target.run();
  4. }
  5. }

五、真正理解Thread类

Thread类的对象其实也是一个java对象,只不过每一个Thread类的对象对应着一个线程。Thread类的对象就是提供给用户用于操作线程、获取线程的信息。真正的底层线程用户是看不到的了。
因此,当一个线程结束了,死掉了,对应的Thread的对象仍能调用,除了start( )方法外的所有方法(死亡的线程不能再次启动),如run( )、getName( )、getPriority()等等


 
 
  1. //简单起见,使用匿名内部类的方法来创建线程
  2. Thread thread = new Thread(){
  3. @ Override
  4. public void run( ) {
  5. System. out.println( "Thread对象的run方法被执行了");
  6. }
  7. };
  8. //线程启动
  9. thread.start();
  10. //用循环去监听线程thread是否还活着,只有当线程thread已经结束了,才跳出循环
  11. while(thread.isAlive()){}
  12. //线程thread结束了,但仍能调用thread对象的大部分方法
  13. System. out.println( "线程"+thread.getName()+ "的状态:"+thread.getState()+ "---优先级:"+thread.getPriority());
  14. //调用run方法
  15. thread.run();
  16. //当线程结束时,start方法不能调用,下面的方法将会抛出异常
  17. thread.start();
参考资料
文章有不当之处,欢迎指正,你也可以关注我的微信公众号: 好好学java,获取优质学习资源。
  • 4
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值