Java中线程常用的方法

男娘i 2022-12-28 00:55 58阅读 0赞

前言：  
线程中常用的方法：  
（1）Thread.currentThread()  
（2）Thread.currentThread().getName()  
（3）Thread.currentThread().setName(’’)  
（4）sleep()  
（5）yield()  
（6）join()  
（7）interrupt()、interrupted()和isInterrupted()  
（8）wait()、notify和notifyAll()

**1. sleep()**

Thread.sleep(1000)  
在指定时间内让当前执行的线程暂停执行一段时间，让其他线程有机会继续执行，但不会释放对象锁，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据，不推荐使用。sleep() 使当前线程进入阻塞状态，在指定时间不会执行，因此sleep()方法常用来暂停线程的执行，当sleep()结束后，然后转入到 Runnable(就绪状态)，这样才能够得到执行的机会。

> 注意是让当前的线程睡眠一段时间

**2.yield()**

Thread.yield( )  
使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。

Java线程中的Thread.yield( )方法，很多人翻译成线程让步。顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，让自己或者其它的线程运行。

代码示例：

package com.yield;
     
    public class YieldTest extends Thread { 
     
    	public YieldTest(String name) { 
    		super(name);
    	}
     
    	@Override
    	public void run() { 
    		for (int i = 1; i <= 50; i++) { 
    			System.out.println("" + this.getName() + "-----" + i);
    			// 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
    			if (i == 30) { 
    				this.yield();
    			}
    		}
    	}
     
    	public static void main(String[] args) { 
    		YieldTest yt1 = new YieldTest("张三");
    		YieldTest yt2 = new YieldTest("李四");
    		yt1.start();
    		yt2.start();
    	}
    }

第一种情况：李四（线程）当执行到30时会CPU时间让掉，这时张三（线程）抢到CPU时间并执行。  
![在这里插入图片描述][20201213090307750.png]  
第二种情况：李四（线程）当执行到30时会CPU时间让掉，这时李四（线程）抢到CPU时间并执行。  
![在这里插入图片描述][20201213090353606.png]

> 注意是让当前线程让出时间片

**3.join()**

join()是Thread类的一个方法，根据jdk文档的定义，join()方法的作用，是等待这个线程结束，即当前线程等待另一个调用join()方法的线程执行结束后在往下执行。通常用于在main主线程内，等待其它调用join()方法的线程执行结束再继续执行main主线程。

代码示例：

public static void main(String[] args){ 
        System.out.println("MainThread run start.");
    
        //启动一个子线程
        Thread threadA = new Thread(new Runnable() { 
            @Override
            public void run() { 
                System.out.println("threadA run start.");
                try { 
                    Thread.sleep(1000);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
                System.out.println("threadA run finished.");
            }
        });
        threadA.start();
    
        System.out.println("MainThread join before");
        try { 
            threadA.join();    //调用join()
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }
        System.out.println("MainThread run finished.");
    }

运行结果如下：

> MainThread run start.  
> threadA run start.  
> MainThread join before  
> threadA run finished.  
> MainThread run finished.

注意：该方法在当前线程中调用，让当前线程等待调用该方法的线程执行完后再继续执行

**4.interrupt()、interrupted() 和 isInterrupted()**

（1）interrupt()  
其作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。interrupt()的作用其实不是中断线程，而是通知线程应该中断了

（2）interrupted()  
作用是测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，第二次再调用时中断状态已经被清除，将返回一个false。

（3）isInterrupted()  
作用是只测试此线程是否被中断 ，不清除中断状态。

代码示例：

public class MyThread extends Thread { 
        @Override
        public  void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("i="+(i+1));
            }
        }
    }

结果如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70]  
从结果可以看出调用interrupt()方法后，线程仍在继续运行，并未停止，但已经给线程设置了中断标志，两个isInterrupted()方法都会输出true，也说明isInterrupted()方法并不会清除中断状态。

修改代码：

public class Do { 
        public static void main(String[] args ) { 
            MyThread thread=new MyThread();
            thread.start();
            thread.interrupt();
            System.out.println("第一次调用thread.isInterrupted()："+thread.isInterrupted());
            System.out.println("第二次调用thread.isInterrupted()："+thread.isInterrupted());
                        //测试interrupted（）函数
            System.out.println("第一次调用thread.interrupted()："+thread.interrupted());
            System.out.println("第二次调用thread.interrupted()："+thread.interrupted());
            System.out.println("thread是否存活："+thread.isAlive());
        }
    }

结果如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 1]  
从输出结果看，可能会有疑惑，为什么后面两个interrupted方法输出的都是false，而不是预料中的一个true一个false？注意！！！这是一个坑！！！上面说到，interrupted()方法测试的是当前线程是否被中断，当前线程！！！当前线程！！！，这里当前线程是main线程，而thread.interrupt(）中断的是thread线程，这里的此线程就是thread线程。所以当前线程main从未被中断过，尽管interrupted()方法是以thread.interrupted()的形式被调用，但它检测的仍然是main线程而不是检测thread线程，所以thread.interrupted()在这里相当于main.interrupted()

> interrupted()方法测试的是当前线程是否被中断。这里有两个线程，一个是main线程，然后在main中开启一个子线程。

再次修改代码：  
Thread.currentThread()函数可以获取当前线程

public class Do { 
        public static void main(String[] args ) throws InterruptedException { 
            Thread.currentThread().interrupt();
            System.out.println("第一次调用Thread.currentThread().interrupt()："
                    +Thread.currentThread().isInterrupted());
            System.out.println("第一次调用thread.interrupted()："
                    +Thread.currentThread().interrupted());
            System.out.println("第二次调用thread.interrupted()："
                    +Thread.currentThread().interrupted());
        }
    }

这里都是针对当前线程在操作，如果interrupted()方法有检测中断并清除中断状态的作用，预料中的输出应该是true-true-false  
结果如图：  
![在这里插入图片描述][20201213093753118.png]  
整体测试代码如下：

public class MyThread extends Thread { 
        @Override
        public  void run() { 
            for (int i = 0; i < 1000; i++) { 
                System.out.println("i="+(i+1));
                if(this.isInterrupted()){ 
                    System.out.println("通过this.isInterrupted()检测到中断");
                    System.out.println("第一个interrupted()"+this.interrupted());
                    System.out.println("第二个interrupted()"+this.interrupted());
                    break;
                }
            }
            System.out.println("因为检测到中断，所以跳出循环，线程到这里结束，因为后面没有内容了");
        }
    }

public class Do { 
        public static void main(String[] args ) throws InterruptedException { 
            MyThread myThread=new MyThread();
            myThread.start();
            myThread.interrupt();
            //sleep等待一秒，等myThread运行完
            Thread.currentThread().sleep(1000);
            System.out.println("myThread线程是否存活："+myThread.isAlive());
        }
    }

结果如图：  
![在这里插入图片描述][20201213094030418.png]

> 解析：  
> 在main线程中开启子线程myThread，然后在main线程中给myThread线程设置中断标志。  
> this.isInterrupted()：this代表正在运行的线程，所以是判断myThread是否含有中断标志，然后跳出循环。isInterrupted()只检测中断，不清楚中断状态

总结：  
a.  
interrupt() 是给线程设置中断标志  
b.  
interrupted() 是检测中断并清除中断状态；（作用当前线程）  
c.  
isInterrupted() 只检测中断。（作用调用的线程）

**5.wait方法**

wait方法是让当前线程等待，这里的当前线程不是指t，而是主线程。 wait会释放锁，等到其他线程调用notify方法时再继续运行。

代码如下：

1 package com.citi.test.mutiplethread.demo0503;
     2 
     3 import java.util.Date;
     4 
     5 public class WaitTest { 
     6     public static void main(String[] args) { 
     7         ThreadA t1=new ThreadA("t1");
     8         System.out.println("t1:"+t1);
     9         synchronized (t1) { 
    10             try { 
    11                 //启动线程
    12                 System.out.println(Thread.currentThread().getName()+" start t1");
    13                 t1.start();
    14                 //主线程等待t1通过notify唤醒。
    15                 System.out.println(Thread.currentThread().getName()+" wait()"+ new Date());
    16                 t1.wait();// 不是使t1线程等待，而是当前执行wait的线程等待
    17                 System.out.println(Thread.currentThread().getName()+" continue"+ new Date());
    18             } catch (Exception e) { 
    19                 e.printStackTrace();
    20             }
    21         }
    22     }
    23 }
    24 
    25 class ThreadA extends Thread{ 
    26     public ThreadA(String name) { 
    27         super(name);
    28     }
    29     @Override
    30     public void run() { 
    31         synchronized (this) { 
    32             System.out.println("this:"+this);
    33             try { 
    34                 Thread.sleep(2000);//使当前线程阻塞1秒
    35             } catch (InterruptedException e) { 
    36                 // TODO Auto-generated catch block
    37                 e.printStackTrace();
    38             }
    39             System.out.println(Thread.currentThread().getName()+" call notify()");
    40             this.notify();
    41         }
    42     }
    43 }

结果如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 2]

> 注意：wait方法是让当前线程等待调用wait方法的线程执行完在继续执行

**6.notify/notifyAll()**

（1）一般情况下wait()和notify/notifyAll()要一起使用  
（2）notify/notifyAll() 方法是Object的本地final方法，无法被重写  
（3）wait()使当前线程阻塞，前提是必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。  
（4）由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。当线程执行wait()方法的时候，会释放当前的锁，然后让出CPU，进入等待状态。只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程让其获得锁  
（5）notify 和 notifyAll的区别：notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。notifyAll 会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒，推荐使用notifyAll 方法。比如在生产者-消费者里面的使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。

**7.线程中的其他常用方法**

（1）Thread.currentThread()：获得当前线程  
（2）Thread.currentThread().getName()：获得当前线程的名称  
（3）Thread.currentThread().setName(’’):设置当前线程的名称

[20201213090307750.png]: /images/20221120/e6f35a6fb6e04f359d00c8d5a03eedf4.png
[20201213090353606.png]: /images/20221120/725f27ba8f8649fd95f091dc4e1b53b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70]: /images/20221120/087b829c268743b5b959f13dfe542cf0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221120/29044ae170fe41e4855332e927e5184b.png
[20201213093753118.png]: /images/20221120/0d42eb6d52174eae87db6710196cb362.png
[20201213094030418.png]: /images/20221120/2d351ceb3fd54ed3abefcbf4d53efd94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 2]: /images/20221120/cd646a8bf366475cbc32fb0d611ce7d8.png