java多线程-初探（二）

左手的ㄟ右手 2022-04-11 02:49 235阅读 0赞

# [java多线程-初探（一）][java_-] #

### 常见的线程函数 ###

<table> 
 <tbody> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:100px;">sleep</td> 
   <td style="text-align:left;width:100px;"> <p>当前线程暂停</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:100px;">join</td> 
   <td style="text-align:left;width:100px;"> <p>加入到当前线程中</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:100px;">setPriority</td> 
   <td style="text-align:left;width:100px;"> <p>线程优先级</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:100px;">yield</td> 
   <td style="text-align:left;width:100px;"> <p>临时暂停</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:100px;">setDaemon</td> 
   <td style="text-align:left;width:100px;"> <p>守护线程</p> </td> 
  </tr> 
 </tbody> 
</table>

**sleep**

当前线程休眠具体的毫秒值后唤醒。

InterruptedException异常：当线程休眠时异常中断将抛出此异常。

class Main

package com.thread.two;
    
    public class Main {
    
        /**
         * 吃饭
         * @param args
         */
        public static void main(String[] args) {
            new Thread(){
                public void run(){
                    long beginTime = System.currentTimeMillis();
                    System.out.println("执行前毫秒数：" + beginTime);
                    // 执行sleep函数。当前调用的线程休眠固定毫秒数
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("执行结束毫秒数：" + endTime);
                    System.out.println("执行花了：" + (endTime - beginTime)/1000 +"秒");
                }
            }.start();
        }
    }

执行结果

![20181204141924560.png][]

**join**

将当前线程加入到主线程。当前线程执行完成，主线程才能接着往下执行。

主线程：执行main函数时，整个进程是一个主线程，主线程从上往下依次执行，遇到Thread类开启多线程时，线程类独立执行，不影响主线程的执行步骤，就是说子线程独立执行，主线程还是往下继续执行。但是当子线程调用join函数加入到主线程当中，则主线程必须等子线程执行完成才能往下继续执行。

class Main

注释thread.join();的执行结果

![20181204143304384.png][]

打开thread.join();的执行结果

![2018120414334776.png][]

**setPriority**

设置线程的优先级，取值范围：1-10

线程优先级越高，该线程越容易获得cpu资源，从而执行自身线程，相较于其他低优先级的线程优先执行。

class Main

数据量小无法体现，这里只截部分执行结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3draF9fXw_size_16_color_FFFFFF_t_70][]

**yield**

临时暂停当前线程，使得其余线程能更容易获得cpu资源执行。

class Main

package com.thread.two;
    
    public class Main {
    
        /**
         * 吃饭
         * @param args
         */
        public static void main(String[] args) {
            /*new Thread(){
                public void run(){
                    long beginTime = System.currentTimeMillis();
                    System.out.println("执行前毫秒数：" + beginTime);
                    // 执行sleep函数。当前调用的线程休眠固定毫秒数
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("执行结束毫秒数：" + endTime);
                    System.out.println("执行花了：" + (endTime - beginTime)/1000 +"秒");
                }
            }.start();*/
    
            /*// join
            System.out.println("我是主线程-begin");
            Thread thread = new Thread() {
                public void run(){
                    // 每个一秒打印一次：我是子线程
                    for(int i = 0 ; i < 3 ; i++){
                        System.out.println("我是子线程");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是主线程-end");*/
    
            /*// setPriority线程优先级
            // 线程1
            Thread thread1 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++){
                        System.out.println("我是线程----1");
                    }
                }
            };
            // 线程二
            Thread thread2 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++) {
                        System.out.println("我是线程----2");
                    }
                }
            };
            // 设置优先级 取值：1-10
            thread1.setPriority(Thread.MIN_PRIORITY);// 最小
            thread2.setPriority(Thread.MAX_PRIORITY);// 最大
            thread1.start();
            thread2.start();*/
    
            // yield 临时暂停
            // 线程1
            Thread thread1 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++){
                        System.out.println("我是线程----1");
                    }
                }
            };
            // 线程二
            Thread thread2 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++) {
                        // 执行一半临时暂停
                        if (i == 50) Thread.yield();
                        System.out.println("我是线程----2");
                    }
                }
            };
            thread1.start();
            thread2.start();
        }
    }

执行结果

![20181204144844798.png][]

**setDaemon**

守护线程，当一个进程里全部都是守护线程时，结束当前整个进程。

守护线程一般用作业务附加的辅助功能，如进程执行的记录日志、检测当前用户状态。

class Main

package com.thread.two;
    
    public class Main {
    
        /**
         * 吃饭
         * @param args
         */
        public static void main(String[] args) {
            /*new Thread(){
                public void run(){
                    long beginTime = System.currentTimeMillis();
                    System.out.println("执行前毫秒数：" + beginTime);
                    // 执行sleep函数。当前调用的线程休眠固定毫秒数
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("执行结束毫秒数：" + endTime);
                    System.out.println("执行花了：" + (endTime - beginTime)/1000 +"秒");
                }
            }.start();*/
    
            /*// join
            System.out.println("我是主线程-begin");
            Thread thread = new Thread() {
                public void run(){
                    // 每个一秒打印一次：我是子线程
                    for(int i = 0 ; i < 3 ; i++){
                        System.out.println("我是子线程");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是主线程-end");*/
    
            /*// setPriority线程优先级
            // 线程1
            Thread thread1 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++){
                        System.out.println("我是线程----1");
                    }
                }
            };
            // 线程二
            Thread thread2 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++) {
                        System.out.println("我是线程----2");
                    }
                }
            };
            // 设置优先级 取值：1-10
            thread1.setPriority(Thread.MIN_PRIORITY);// 最小
            thread2.setPriority(Thread.MAX_PRIORITY);// 最大
            thread1.start();
            thread2.start();*/
    
            /*// yield 临时暂停
            // 线程1
            Thread thread1 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++){
                        System.out.println("我是线程----1");
                    }
                }
            };
            // 线程二
            Thread thread2 = new Thread(){
                public void run(){
                    for (int i = 0 ; i < 100 ; i++) {
                        // 执行一半临时暂停
                        if (i == 50) Thread.yield();
                        System.out.println("我是线程----2");
                    }
                }
            };
            thread1.start();
            thread2.start();*/
    
            // setDaemon 守护线程
            System.out.println("主线程开始");
            Thread thread = new Thread(){
                public void run(){
                    while (true){
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("我是守护线程！");
                    }
                }
            };
            thread.setDaemon(true);
            thread.start();
            System.out.println("主线程结束");
        }
    }

执行结果

![2018120414581140.png][]

主线程结束，守护线程也相应结束，不会继续执行。

**当所有线程都是守护线程时，进程结束执行。**

### [java多线程-初探（三）][java_- 1] ###

[java_-]: https://blog.csdn.net/wkh___/article/details/84785760
[20181204141924560.png]: /images/20220411/86d2cabbf8f445a99e6c0cda2a1a106f.png
[20181204143304384.png]: /images/20220411/8972e581c902480f8664d34c332e1df2.png
[2018120414334776.png]: /images/20220411/53fbd04cf5224e45bfbbf7e81b35fceb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3draF9fXw_size_16_color_FFFFFF_t_70]: /images/20220411/f9b64f9e0222452c98f022c8fb2fcef4.png
[20181204144844798.png]: /images/20220411/6b5f67af0d4245029230f87d26d799f7.png
[2018120414581140.png]: /images/20220411/2f362d8a0b054292aa96d38f35329a36.png
[java_- 1]: https://blog.csdn.net/wkh___/article/details/84818655