多线程(二):Thread类的常见方法

你的名字 2023-10-02 20:38 22阅读 0赞

> 往期回顾:  
> ❀❀[多线程(一):认识和创建一个线程][Link 1]❀❀

#### Thread类的常见方法 ####

*  一.构造方法
 *  二.常见属性
 *   *   *  1.ID
         *  2.Name
         *  3.状态
         *  4.优先级
         *  5.是否守护线程
         *  6.是否存活
         *  7.是否被中断
 *  三.常见方法
 *   *   *  1.start()
         *  2.interrupt(),isInterrupted(),interrupted()
         *  3.join()
         *  4.获取当前线程引用
         *  5.线程休眠

--------------------

## 一.构造方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread()</td> 
   <td>创建线程对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td>使用 Runnable 对象创建线程对象</td> 
  </tr> 
  <tr> 
   <td>Thread(String name)</td> 
   <td>创建线程对象，并命名</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target, String name)</td> 
   <td>使用 Runnable 对象创建线程对象，并命名</td> 
  </tr> 
 </tbody> 
</table>

public class ThreadMethod{
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread();
            Thread t2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("创建一个线程");
                }
            });
            Thread t3 = new Thread("我是一个线程");
            Thread t4 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("创建一个线程");
                }
            },"我也是线程");
        }
    }

## 二.常见属性 ##

#### 1.ID ####

> ID 是线程的唯一标识，不同线程不会重复,使用getId()获取

#### 2.Name ####

> name属性通常用于调试程序

Thread thread1 = new Thread(new MyThread(),"thread1");
            Thread thread2 = new Thread(new MyThread(),"thread2");
            System.out.println("thread1.getId() = " + thread1.getId());
            System.out.println("thread2.getId() = " + thread2.getId());
            System.out.println("thread1.getName() = " + thread1.getName());
            System.out.println("thread2.getName() = " + thread2.getName());

![在这里插入图片描述][ffab045e7f57418284d22a6435b83426.png]

#### 3.状态 ####

> 在Java当中把对线程的状态分得比原生操作系统更加细致,在`Thread`类内部,定义了一个枚举类型`State`,定义了线程的***6***种状态,如下

public enum State {
        
            
            NEW,
    
            RUNNABLE,
    
            BLOCKED,
    
            WAITING,
    
            TIMED_WAITING,
    
            TERMINATED;
        }

> 1.  `NEW:`线程刚创建出来,还未执行`start()`方法之前处于`NEW`状态.
> 
>     Thread thread = new Thread(new ThreadMethod());
>             System.out.println("thread.getState() = " + thread.getState());
> 
> ![在这里插入图片描述][7305e60950bb4e6f865b5f2ad08f0597.png]

> 2.`RUNNABLE:`线程处于运行状态或者处在就绪队列,等待CPU资源
> 
>     Thread thread = new Thread(new ThreadMethod());
>            System.out.println("thread.getState() = " + thread.getState());
>            thread.start();
>            System.out.println("thread.getState() = " + thread.getState());
> 
> ![在这里插入图片描述][eed969032c64435c8ee5b0ac07df85cb.png]

> 3.`TERMINATED`结束状态,表示线程已经执行完毕
> 
>     Thread thread = new Thread(new ThreadMethod());
>            System.out.println("thread.getState() = " + thread.getState());
>            thread.start();
>            System.out.println("thread.getState() = " + thread.getState());
>            Thread.sleep(100);
>            System.out.println("thread.getState() = " + thread.getState());
> 
> ![在这里插入图片描述][06d53451524b42f99fa25c1f17f71851.png]

> 4.`BLOCKED:` 这个状态表示线程正在等待锁资源
> 
>     public class ThreadDemo implements Runnable {
>          
>     
>         private static final Object lock = new Object();
>     
>         public static void main(String[] args) throws InterruptedException {
>          
>             Thread thread = new Thread(new ThreadDemo());
>             thread.start();
>             Thread thread1 = new Thread(new ThreadDemo());
>             thread1.start();
>             Thread.sleep(1000);
>             System.out.println("thread1.getState() = " + thread1.getState());
>         }
>         @Override
>         public void run() {
>          
>             synchronized (lock){
>          
>                 System.out.println(Thread.currentThread().getName()+" synchronized 加锁");
>                 // 休眠 5 秒
>                 try {
>          
>                     Thread.sleep(5000);
>                 } catch (InterruptedException e) {
>          
>                     e.printStackTrace();
>                 }
>                 System.out.println(Thread.currentThread().getName()+" synchronized 释放锁");
>             }
>         }
>     }
> 
> 可以看到,当`thread`开始执行时,进入`synchronized`代码块,而后来的线程`thread`因为无法进入`synchronized`而阻塞,进入`BLOCKED`状态  
> ![在这里插入图片描述][8bf021e605fd417b9de00f1aaa6f7bc6.png]

> 5.`WAITING:` 查看源码–>  
> ![在这里插入图片描述][cb6d775cac6347f5b502190d12bf9961.png]  
> 发现,当线程调用上面3个方法时,会进入`WAITING`状态  
> `如:`
> 
>     public class ThreadState implements Runnable{
>          
>         @Override
>         public synchronized void run() {
>          
>             while (true) {
>          
>                 try {
>          
>                     this.wait();
>                     this.notify();
>                 } catch (InterruptedException e) {
>          
>                     e.printStackTrace();
>                 }
>             }
>         }
>     
>         public static void main(String[] args) throws InterruptedException {
>          
>             Thread thread = new Thread(new ThreadState());
>             thread.start();
>             Thread.sleep(1000);
>             System.out.println("thread.getState() = " + thread.getState());
>         } }
> 
> ![在这里插入图片描述][71163ee0fc7642bca04addf928d884a3.png]  
>

> 6.`TIMED_WAITING:` 查看源码–>  
> ![在这里插入图片描述][5ebd6bf6929c4d358111593c42528d08.png]  
> 当线程进入有限等待时进入`TIMED_WAITING`状态.
> 
> `如:`
> 
>     public class ThreadState implements Runnable{
>          
>         @Override
>         public void run() {
>          
>             try {
>          
>                 Thread.sleep(10000);
>             } catch (InterruptedException e) {
>          
>                 e.printStackTrace();
>             }
>         }
>         public static void main(String[] args) throws InterruptedException {
>          
>             Thread thread = new Thread(new ThreadState());
>             thread.start();
>             Thread.sleep(1000);
>             System.out.println("thread.getState() = " + thread.getState());
>         } }
> 
> 输出  
> ![在这里插入图片描述][6a293949f26a489ea97365fdd27b89de.png]  
> `同理join()与wait()带参数的版本可以达到同样的效果`

#### 4.优先级 ####

> 优先级高的线程`理论上`来说更容易被调度到  
> 具体的调用规则由操作系统内核决定.

thread1.setPriority(2);
            System.out.println("thread1.getPriority() = " + thread1.getPriority());

![在这里插入图片描述][522261a1965b4aaa9c0b790e3aca6b92.png]

> \*\*Thread提供的优先级为10个等级,1为支持得最小优先级,10为最大,如果设置的优先级不在1~10之间,会抛出异常![在这里插入图片描述][b97d8e92de4149148b1902b0cdd459ea.png]  
> 当创建一个线程时,默认的优先级为*5*

#### 5.是否守护线程 ####

> 守护线程区分与用户进程
> 
> > 守护进程:是一种特殊的进程,为用户进程提供服务的一种进程,当用户进程全部执行完毕后,虚拟机会kill全部的守护进程  
> > 用户进程:一个进程运行时,默认都是用户进程,要想让线程变为守护进程,需要调用 `setDaemon()`方法

**实例 1:**

> 当`thread`不是守护线程时,main()线程结束后,程序继续运行,且在死循环中无法退出.

class MyThread implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 1 ; ; ++i){
        
                System.out.println("i = " + i);
            }
        }
    }
    
    public class ThreadMethod{
        
        public static void main(String[] args) {
        
            System.out.println("main() 线程开始运行..");
    
            Thread thread = new Thread(new MyThread());
            
            thread.start();
        }
    }

![在这里插入图片描述][4360d5f8c66f43f0bf06a5ef58d3ab3c.png]

> 当把`thread`设置为守护线程时,`main()`线程结束后,程序就结束了,`thread`线程被`kill`

System.out.println("main() 线程开始运行..");
    
            Thread thread = new Thread(new MyThread());
            // 设置thread为守护线程
            thread.setDaemon(true);
            thread.start();

![在这里插入图片描述][37ab38eca8ba440186994e1f5c8c3166.png]  
**实例 2:**

> 形如垃圾回收线程,当用户进程结束时,也就不会产生垃圾,也就不需要垃圾回收了.

#### 6.是否存活 ####

> run 方法执行结束前,线程存活

class MyThread implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 1 ; i <  5; ++i){
        
                System.out.println("i = " + i);
            }
        }
    }
    
    public class ThreadMethod{
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread thread = new Thread(new MyThread());
            System.out.println("thread.isAlive() = " + thread.isAlive());
            thread.start();
            System.out.println("thread.isAlive() = " + thread.isAlive());
            Thread.sleep(100L);   // 让线程休眠 100 ms
            System.out.println("thread.isAlive() = " + thread.isAlive());
    	}
    }

![在这里插入图片描述][371cf68bcae74536ab2ee9076cddec45.png]

#### 7.是否被中断 ####

> 使用`thread.isInterrupted()`判断线程是否被中断,被中断返回`true`  
> 使用`thread.intrerupt()`中断`thread`线程

## 三.常见方法 ##

#### 1.start() ####

> 重写`run()`方法时,就是指定线程任务,当我们`new Thread()`时,并不代表线程开始运行,只有当我们调用`start()`方法时,才会在操作系统底层创建出一个线程.

#### 2.interrupt(),isInterrupted(),interrupted() ####

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void interrupt()</td> 
   <td>中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位为<code>true</code></td> 
  </tr> 
  <tr> 
   <td>public static boolean interrupted()</td> 
   <td>判断当前线程的中断标志位是否为<code>true</code>，调用后将标志位设置为<code>false</code></td> 
  </tr> 
  <tr> 
   <td>public boolean isInterrupted()</td> 
   <td>判断对象关联的线程的标志位是否为<code>true</code>，调用后不改变标志位</td> 
  </tr> 
 </tbody> 
</table>

(1).使用自定义的变量来作为标志位.

public class ThreadMethod implements Runnable{
        
        @Override
        public void run() {
        
        	// 当isQuit为false进入循环
            while (!isQuit){
        
                System.out.println("线程运行中");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            System.out.println("线程结束");
        }
        private static boolean isQuit = false;
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread thread = new Thread(new ThreadMethod());
            thread.start();
            Thread.sleep(6000);
            // 休眠6s后,将标志位设置位ture,循环条件不满足,结束thread线程
            isQuit = true;
        }
    }

> 运行结果  
> ![在这里插入图片描述][1d0729d984394cd284407357a7c9488b.png]

(2).使用`thread.isInterrupted()`代替标志位

public class ThreadMethod implements Runnable{
        
        @Override
        public void run() {
        
            while (!Thread.currentThread().isInterrupted()){
        
                System.out.println("线程运行中");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            System.out.println("线程结束");
        }
    //    private static boolean isQuit = false;
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread thread = new Thread(new ThreadMethod());
            thread.start();
            System.out.println("thread.isInterrupted() = " + thread.isInterrupted());
            Thread.sleep(6000);
            thread.interrupt();
            System.out.println("thread.isInterrupted() = " + thread.isInterrupted());
    	}
    }

> `Thread.currentThread()`为获取**当前线程**引用

> 运行上述代码,得到如下结果  
> ![在这里插入图片描述][eb38e861ce034afaa111f7786dfc3e1c.png]  
> 可以发现,程序抛出异常,并且循环并没有结束,因为当程序执行`thread.interrupt();`的时候,有两种情况
> 
> > 1: 当线程处在运行状态,`interrupt()`会修改标志位为`true`.  
> > 2.当线程处于阻塞状态时,会抛出`InterruptedException()`异常,此时程序是否继续运行,取决于代码中`catch`中的实现.

(3).观察`interrupted()`与`isInterrupted()`的区别

> `interrupted()`与`isInterrupted()`的区别在于执行后是否将标志位重置为`false`

// isInterrupted()演示
    public class ThreadMethod implements Runnable {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println("Thread.currentThread().isInterrupted() = " + Thread.currentThread().isInterrupted());
            }
        }
    
        //    private static boolean isQuit = false;
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread thread = new Thread(new ThreadMethod());
            thread.start();
            thread.interrupt();
        }
    }

> 输出  
> ![在这里插入图片描述][179051c9fc634301bc04cd433de6c469.png]  
> 因为标记为未被重置,所以全部输出true

// Thread.interrupted()演示
    public class ThreadMethod implements Runnable {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println("Thread.interrupted() = " + Thread.interrupted());
            }
        }
    
        //    private static boolean isQuit = false;
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread thread = new Thread(new ThreadMethod());
            thread.start();
            thread.interrupt();
        }
    }

> 输出  
> ![在这里插入图片描述][18944e437ead4861a27bba49d0de7b2a.png]  
> 因为输出 `true`之后,标记为被重置,所以后续输出 `false`

#### 3.join() ####

> 当一个线程A调用某一个线程B的`join()`方法时,当前线程A将会进入等待状态,只有当B线程执行完毕之后,A线程才能继续执行.

public class ThreadMethod implements Runnable {
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName()+"开始运行");
            for (int i = 1; i <= 10; i++) {
        
                System.out.println(i);
            }
            System.out.println(Thread.currentThread().getName()+"结束运行");
        }
    
        //    private static boolean isQuit = false;
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread thread = new Thread(new ThreadMethod(),"thread");
            thread.start();
            System.out.println("main() 线程结束...");
        }
    }

> 运行结果  
> ![在这里插入图片描述][b9237915042f4ecbadf0c4d6dbb91f19.png]  
> **可以发现,当程序运行时,`main`线程先执行完毕,`thread`线程才开始执行,那么,如何让`thread`线程执行完毕之后,`main`线程才结束呢**

Thread thread = new Thread(new ThreadMethod(),"thread");
            thread.start();
            // 加入 thread.join() 这是,main将等待 thread结束之后才会继续往下执行
            thread.join();
            System.out.println("main() 线程结束...");

> 结果  
> ![在这里插入图片描述][983514af93de473e93ef6b32bcd69906.png]

**除此之外,join()还可以传入一个毫秒数,代表最多等待多久**

#### 4.获取当前线程引用 ####

> `Thread.currentThread();`

#### 5.线程休眠 ####

> `public static void sleep(long millis) throws InterruptedException`,millis为休眠的毫秒数,这个方法可能会抛出异常

> 系列文章❀❀❀[多线程(一):认识和创建一个线程][Link 2]❀❀❀❀❀❀[多线程(三):synchronized解决线程不安全][synchronized]❀❀❀

[Link 1]: http://t.csdn.cn/vy9CT
[ffab045e7f57418284d22a6435b83426.png]: https://img-blog.csdnimg.cn/ffab045e7f57418284d22a6435b83426.png
[7305e60950bb4e6f865b5f2ad08f0597.png]: https://img-blog.csdnimg.cn/7305e60950bb4e6f865b5f2ad08f0597.png
[eed969032c64435c8ee5b0ac07df85cb.png]: https://img-blog.csdnimg.cn/eed969032c64435c8ee5b0ac07df85cb.png
[06d53451524b42f99fa25c1f17f71851.png]: https://img-blog.csdnimg.cn/06d53451524b42f99fa25c1f17f71851.png
[8bf021e605fd417b9de00f1aaa6f7bc6.png]: https://img-blog.csdnimg.cn/8bf021e605fd417b9de00f1aaa6f7bc6.png
[cb6d775cac6347f5b502190d12bf9961.png]: https://img-blog.csdnimg.cn/cb6d775cac6347f5b502190d12bf9961.png
[71163ee0fc7642bca04addf928d884a3.png]: https://img-blog.csdnimg.cn/71163ee0fc7642bca04addf928d884a3.png
[5ebd6bf6929c4d358111593c42528d08.png]: https://img-blog.csdnimg.cn/5ebd6bf6929c4d358111593c42528d08.png
[6a293949f26a489ea97365fdd27b89de.png]: https://img-blog.csdnimg.cn/6a293949f26a489ea97365fdd27b89de.png
[522261a1965b4aaa9c0b790e3aca6b92.png]: https://img-blog.csdnimg.cn/522261a1965b4aaa9c0b790e3aca6b92.png
[b97d8e92de4149148b1902b0cdd459ea.png]: https://img-blog.csdnimg.cn/b97d8e92de4149148b1902b0cdd459ea.png
[4360d5f8c66f43f0bf06a5ef58d3ab3c.png]: https://img-blog.csdnimg.cn/4360d5f8c66f43f0bf06a5ef58d3ab3c.png
[37ab38eca8ba440186994e1f5c8c3166.png]: https://img-blog.csdnimg.cn/37ab38eca8ba440186994e1f5c8c3166.png
[371cf68bcae74536ab2ee9076cddec45.png]: https://img-blog.csdnimg.cn/371cf68bcae74536ab2ee9076cddec45.png
[1d0729d984394cd284407357a7c9488b.png]: https://img-blog.csdnimg.cn/1d0729d984394cd284407357a7c9488b.png
[eb38e861ce034afaa111f7786dfc3e1c.png]: https://img-blog.csdnimg.cn/eb38e861ce034afaa111f7786dfc3e1c.png
[179051c9fc634301bc04cd433de6c469.png]: https://img-blog.csdnimg.cn/179051c9fc634301bc04cd433de6c469.png
[18944e437ead4861a27bba49d0de7b2a.png]: https://img-blog.csdnimg.cn/18944e437ead4861a27bba49d0de7b2a.png
[b9237915042f4ecbadf0c4d6dbb91f19.png]: https://img-blog.csdnimg.cn/b9237915042f4ecbadf0c4d6dbb91f19.png
[983514af93de473e93ef6b32bcd69906.png]: https://img-blog.csdnimg.cn/983514af93de473e93ef6b32bcd69906.png
[Link 2]: http://t.csdn.cn/fhcbd
[synchronized]: http://t.csdn.cn/AIZMJ