Thread类

最新推荐文章于 2024-01-20 20:42:04 发布
最新推荐文章于 2024-01-20 20:42:04 发布
阅读量157 收藏
点赞数
分类专栏： java基础

1 start方法

　　start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

　　2 run方法

　　run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

补充：用start()方法来启动线程，是真正实现了多线程，通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，无需等待run方法执行完毕，即可继续执行下面的代码。

所以说：

start()方法是真正实现了多线程run()方法只是一个普通的方法。

　　3 sleep方法

　　sleep方法有两个重载版本：

1
2
3
sleep( long  millis)      //参数为毫秒
 
sleep( long  millis, int  nanoseconds)     //第一参数为毫秒，第二个参数为纳秒
　　
　　sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。

　    但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。看下面这个例子就清楚了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public  class  Test {
     
     private  int  i =  10 ;
     private  Object object =  new  Object();
     
     public  static  void  main(String[] args)  throws  IOException  {
         Test test =  new  Test();
         MyThread thread1 = test. new  MyThread();
         MyThread thread2 = test. new  MyThread();
         thread1.start();
         thread2.start();
     } 
     
     
     class  MyThread  extends  Thread{
         @Override
         public  void  run() {
             synchronized  (object) {
                 i++;
                 System.out.println( "i:" +i);
                 try  {
                     System.out.println( "线程" +Thread.currentThread().getName()+ "进入睡眠状态" );　　
                     Thread.currentThread().sleep( 10000 );
                 }  catch  (InterruptedException e) {
                     // TODO: handle exception
                 }
                 System.out.println( "线程" +Thread.currentThread().getName()+ "睡眠结束" );
                 i++;
                 System.out.println( "i:" +i);
             }
         }
     }
}

Thread.currentThread().getName() 此方法的作用是获取线程名

输出结果：

　　从上面输出结果可以看出，当Thread-0进入睡眠状态之后，Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后，此时Thread-0释放了对象锁，Thread-1才开始执行。

　　注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。

　　4）yield方法

　　调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

　　注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

　　5）join方法

　　join方法有三个重载版本：

1
2
3
join()
join( long  millis)      //参数为毫秒
join( long  millis, int  nanoseconds)     //第一参数为毫秒，第二个参数为纳秒

 　　假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的时间。

　　看下面一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public  class  Test {
     
     public  static  void  main(String[] args)  throws  IOException  {
         System.out.println( "进入线程" +Thread.currentThread().getName());
         Test test =  new  Test();
         MyThread thread1 = test. new  MyThread();
         thread1.start();
         try  {
             System.out.println( "线程" +Thread.currentThread().getName()+ "等待" );
             thread1.join();
             System.out.println( "线程" +Thread.currentThread().getName()+ "继续执行" );
         }  catch  (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     } 
     
     class  MyThread  extends  Thread{
         @Override
         public  void  run() {
             System.out.println( "进入线程" +Thread.currentThread().getName());
             try  {
                 Thread.currentThread().sleep( 5000 );
             }  catch  (InterruptedException e) {
                 // TODO: handle exception
             }
             System.out.println( "线程" +Thread.currentThread().getName()+ "执行完毕" );
         }
     }
}

结果：Thread-0调用完毕后才继续执行main线程

wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。

由于wait方法会让线程释放对象锁，所以join方法同样会让线程释放对一个对象持有的锁。具体的wait方法使用在后面文章中给出。

　　6）interrupt方法

　　interrupt，顾名思义，即中断的意思。单独调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常，也就说，它可以用来中断一个正处于阻塞状态的线程；另外，通过interrupt方法和isInterrupted()方法来停止正在运行的线程。

　　下面看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public  class  Test {
     
     public  static  void  main(String[] args)  throws  IOException  {
         Test test =  new  Test();
         MyThread thread = test. new  MyThread();
         thread.start();
         try  {
             Thread.currentThread().sleep( 2000 );
         }  catch  (InterruptedException e) {
             
         }
         thread.interrupt();
     } 
     
     class  MyThread  extends  Thread{
         @Override
         public  void  run() {
             try  {
                 System.out.println( "进入睡眠状态" );
                 Thread.currentThread().sleep( 10000 );
                 System.out.println( "睡眠完毕" );
             }  catch  (InterruptedException e) {
                 System.out.println( "得到中断异常" );
             }
             System.out.println( "run方法执行完毕" );
         }
     }
}

 　　输出结果：

　　

　　从这里可以看出，通过interrupt方法可以中断处于阻塞状态的线程。那么能不能中断处于非阻塞状态的线程呢？看下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public  class  Test {
     
     public  static  void  main(String[] args)  throws  IOException  {
         Test test =  new  Test();
         MyThread thread = test. new  MyThread();
         thread.start();
         try  {
             Thread.currentThread().sleep( 2000 );
         }  catch  (InterruptedException e) {
             
         }
         thread.interrupt();
     } 
     
     class  MyThread  extends  Thread{
         @Override
         public  void  run() {
             int  i =  0 ;
             while (i<Integer.MAX_VALUE){
                 System.out.println(i+ " while循环" );
                 i++;
             }
         }
     }
}

 　　运行该程序会发现，while循环会一直运行直到变量i的值超出Integer.MAX_VALUE。所以说直接调用interrupt方法不能中断正在运行中的线程。

　　但是如果配合isInterrupted()能够中断正在运行的线程，因为调用interrupt方法相当于将中断标志位置为true，那么可以通过调用isInterrupted()判断中断标志是否被置位来中断线程的执行。比如下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public  class  Test {
     
     public  static  void  main(String[] args)  throws  IOException  {
         Test test =  new  Test();
         MyThread thread = test. new  MyThread();
         thread.start();
         try  {
             Thread.currentThread().sleep( 2000 );
         }  catch  (InterruptedException e) {
             
         }
         thread.interrupt();
     } 
     
     class  MyThread  extends  Thread{
         @Override
         public  void  run() {
             int  i =  0 ;
             while (!isInterrupted() && i<Integer.MAX_VALUE){
                 System.out.println(i+ " while循环" );
                 i++;
             }
         }
     }
}

 　　运行会发现，打印若干个值之后，while循环就停止打印了。

　　但是一般情况下不建议通过这种方式来中断线程，一般会在MyThread类中增加一个属性 isStop来标志是否结束while循环，然后再在while循环中判断isStop的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class  MyThread  extends  Thread{
         private  volatile  boolean  isStop =  false ;
         @Override
         public  void  run() {
             int  i =  0 ;
             while (!isStop){
                 i++;
             }
         }
         
         public  void  setStop( boolean  stop){
             this .isStop = stop;
         }
     }

 　　那么就可以在外面通过调用setStop方法来终止while循环。

　　7）stop方法

　　stop方法已经是一个废弃的方法，它是一个不安全的方法。因为调用stop方法会直接终止run方法的调用，并且会抛出一个ThreadDeath错误，如果线程持有某个对象锁的话，会完全释放锁，导致对象状态不一致。所以stop方法基本是不会被用到的。

　　8）destroy方法

　　destroy方法也是废弃的方法。基本不会被使用到。

　　以下是关系到线程属性的几个方法：

　　1）getId

　　用来得到线程ID

　　2）getName和setName

　　用来得到或者设置线程名称。

　　3）getPriority和setPriority

　　用来获取和设置线程优先级。

　　4）setDaemon和isDaemon

　　用来设置线程是否成为守护线程和判断线程是否是守护线程。

　　守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

　　Thread类有一个比较常用的静态方法currentThread()用来获取当前线程。

yangzhen925
关注
专栏目录
【多线程】Thread类
程序猿教你打篮球的博客
04-17 7685
本期主要讲解： 1.Java 中如何进行多线程编程? 2.简单使用多线程 3.start和run的区别 4. jconsole 工具 5.Java中创建线程的写法 6.Thread类方法介绍 6.1构造方法 6.2 Thread类常见属性 6.3什么是守护线程? 6.5什么情况线程才是存活的? 6.6什么是线程中断?
Java多线程之线程的创建与Thread类的使用
未见花闻的博客
03-29 2725
本篇文章介绍java多线程中Thread类的使用以及有关线程对象创建和常用方法。
Thread类详解
在路上
03-05 2289
Thread类构造方法 创建Thread对象，默认有一个线程名，以Thread-开头，按序增加的数字，从0开始 如果在构造Thread的时候没有传递Runnable或者没有复写Thread的run方法，该Thread不会执行任何东西。 如果构造Thread对象是没有传入ThreadGroup，则默认获取父线程的group作为当前线程的group。此时子线程和父线程在同一个group中 Thre...
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1979
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
Thread 类
weixin_43918196的博客
10-25 99
关于Thread类
厚积薄发
08-31 106
1. Thread类也实现了Runnable接口, 因此可以使用Thread(Runnable target)构造函数初始化实例变量. [code="java"] public Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); }[/code] 在Thread类...
多线程-Thread类及常见方法
最新发布
weixin_71841320的博客
01-20 1303
Thread类是Java编程语言中的一个重要类，用于支持多线程编程。它是java.lang包中的一部分，提供了创建和管理线程的方法和功能。通过使用Thread类，可以同时执行多个任务，实现并行处理。每个线程都有独立的执行路径，可以在不同的时间段内独立运行。这使得程序能够更高效地利用计算机的资源，并提高应用程序的响应速度。Thread类提供了许多方法来管理线程的行为，例如start()方法用于启动线程，join()方法用于等待线程的结束，sleep()方法用于暂停线程的执行等等。
thread 类
07-26
NULL 博文链接：https://j2ee2009.iteye.com/blog/664223
关于Thread类的使用和说明
zhimou_qu的博客
04-28 330
前言：    在Java中使用多线程的方式有俩种，一种是实现Runnable接口，另一种则是继承Thread类（实际上也是实现Runnable），但最终开启线程的方式只能是Thread的start方法，其调用了底层native方法启动线程。线程的状态分为6种：线程中用int表示，从上到下（0-5）NEW：                // 线程创建时的初始状态，例如new Thread();RU...
Java中的Thread类
热门推荐
qq_774952435的博客
03-21 1万+
线程
【JavaEE】Thread类
m0_73067372的博客
05-05 332
Java标准库中Thread类可以视为是对操作系统提供的API进行了进一步的抽象和封装。内部类是定义在类里面的有名字的类，匿名内部类是定义在类里面没有名字的类。//此处实现的匿名内部类是实现了Runnable接口的//这里的new表示的是创建对象的动作，//Runnable(),接口名称就是匿名内部类需要实现的那个接口//{..}表示的是匿名内部类的内容@Overridetry {});t.start();try {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值