Java 线程类中常用的方法

短命女 2022-11-04 14:27 151阅读 0赞

# Thread 常用方法 #

先回顾一下我们之前用过的一些方法：

*  `start()`：启动当前线程
 *  `run()`：线程类继承Thread类或者实现Runnable接口的时候，都要实现这个run()方法，run()方法里面是线程要执行的内容。
 *  `currentThread()`：Thread类中的一个静态方法：获取当前正在执行的线程。
 *  `setName()`：设置线程名字。
 *  `getName()`：获取线程名字。

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

## 1. 设置优先级 `setPriority()` ##

同优先级别的线程，采取的策略就是先到先服务，使用时间片策略。  
如果优先级别高，被CPU调度的概率就高。

**使用`setPriority()`方法来设置线程的优先级别。**

> 我们查看Thread类的源代码，级别从1到10，默认的级别是5。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]

示例：

package com.veeja.thread.testPriority;
    
    /** * @Author veeja * 2021/3/3 10:12 */
    class TestThread1 extends Thread { 
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("1: " + i);
            }
        }
    }
    
    class TestThread2 extends Thread { 
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("2: " + i);
            }
        }
    }
    
    
    public class Test { 
        public static void main(String[] args) { 
            TestThread1 t1 = new TestThread1();
            t1.setPriority(1);
            TestThread2 t2 = new TestThread2();
            t2.setPriority(10);
    
            t1.start();
            t2.start();
        }
    }

## 2. 线程插队方法`join()` ##

**当在某个线程中调用其他线程的`join()`方法的时候，调用的线程将被阻塞，直到被join()方法加入的线程执行完毕后才会继续运行。**

例如：

public class Test { 
        public static void main(String[] args) throws InterruptedException { 
            for (int i = 0; i < 10; i++) { 
                if (i == 6) { 
                    TestThread tt = new TestThread();
                    tt.start();
                    tt.join();
                }
                System.out.println(i);
            }
    
        }
    }
    
    class TestThread extends Thread { 
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("我是TestThread：" + i);
            }
        }
    }

结果：

0
    1
    2
    3
    4
    5
    我是TestThread：0
    我是TestThread：1
    我是TestThread：2
    我是TestThread：3
    我是TestThread：4
    我是TestThread：5
    我是TestThread：6
    我是TestThread：7
    我是TestThread：8
    我是TestThread：9
    6
    7
    8
    9

## 3. 线程休眠方法 `sleep()` ##

如果希望人为地控制线程,使正在执行的线程暂停,将CPU让给别的线程,这时可以使用静态方法 `sleep(long millis)`,该方法可以让当前正在执行的线程暂停一段时间，进入休眠等待状态。

当前线程调用`sleep(long millis)`方法后,在指定时间(参数millis)内是不会执行的,这样其他的线程就可以得到执行的机会了。

例如：

public static void main(String[] args) throws InterruptedException { 
        for (int i = 0; i <= 10; i++) { 
            System.out.println(i);
            Thread.sleep(1000);
        }
    }

> sleep()方法会抛出InterruptedException 异常，因此在调用这个方法的时候，应该捕获该异常或者声明抛出该异常。  
> sleep()是静态方法，只能控制正在运行的线程休眠，不能控制其他进程休眠，当休眠时间结束后，线程就会返回到就绪状态，而不是立即开始执行。

## 4. 设置伴随线程`setDaemon()` ##

设置伴随线程，当把子线程设置为主线程的伴随线程后，主线程停止的时候，子线程也将停止执行。

package com.veeja.thread.testSleep.testDaemon;
    
    /** * @Author veeja * 2021/3/3 14:29 */
    public class Test { 
        public static void main(String[] args) throws InterruptedException { 
            TestThread tt = new TestThread();
            // 将tt设置为伴随线程，先设置，再启动
            tt.setDaemon(true);
            tt.start();
    
            for (int i = 0; i < 10; i++) { 
                Thread.sleep(100);
                System.out.println("\tmain :" + i);
            }
        }
    }
    
    class TestThread extends Thread { 
        @Override
        public void run() { 
            for (int i = 0; i < 200; i++) { 
                try { 
                    sleep(10);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println("\t子线程----:" + i);
            }
        }
    }

打印结果：

...
    	子线程----:68
    	子线程----:69
    	子线程----:70
    	子线程----:71
    	子线程----:72
    	main :7
    	子线程----:73
    	子线程----:74
    	子线程----:75
    	子线程----:76
    	子线程----:77
    	子线程----:78
    	子线程----:79
    	子线程----:80
    	main :8
    	子线程----:81
    	子线程----:82
    	子线程----:83
    	子线程----:84
    	子线程----:85
    	子线程----:86
    	子线程----:87
    	子线程----:88
    	子线程----:89
    	main :9

> 注意：  
> 要将某个线程设置为后台线程,必须在该线程启动之前,也就是说`setDaemon()`方法必须在`start()`方法之前调用,否则会引发`IllegalThreadStateException`异常。

## 5. 停止线程 `stop()`方法 ##

stop()用于停止一个线程，此方法已经被废弃，尽量少使用。

public static void main(String[] args) throws InterruptedException { 
        for (int i = 0; i < 10; i++) { 
            Thread.sleep(1000);
            if (i == 6) { 
                Thread.currentThread().stop();
            }
            System.out.println(i);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20221023/ba743eb658fc458d8841e6214007403e.png