(Java 高并发程序设计) 一篇文章带你深入了解多线程中的线程组，守护线程，线程优先级，synchronize

ゝ一世哀愁。 2022-12-21 10:53 166阅读 0赞

### 文章目录 ###

*   *  一、线程组
     *  二、守护线程
     *  三、线程优先级
     *  四、线程安全的概念与关键字 synchronized

## 一、线程组 ##

在一个系统中，如果线程数量很多，而且功能分配比较明确，就可以将相同功能的线程放置在同一个线程组里。打个比方，如果你有一个苹果，你可以把它拿在手里，但是如果你有十个苹果，你最好还有一个篮子，否则不方便携带。对于多线程来说，也是这个道理。想要轻松处理几十个甚至上百个线程，最好还是将它们都装进对应的篮子里。

线程组的使用非常简单，如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]  
上述代码第3行建立了一个名为“PrintGroup”的线程组，并将T1和T2两个线程加入这个组中。第4、5两行代码创建了两个线程，使用Thread的构造函数，指定线程所属的线程组，将线程和线程组关联起来。第8、9两行代码展示了线程组的两个重要的功能：`activeCount()`方法可以获得活动线程的总数，但由于线程是动态的，因此这个值只是一个估计值，无法精确；`list()`方法可以打印这个线程组中所有的线程信息，对调试有一定帮助。

线程组还有一个值得注意的方法`stop()`，它会停止线程组中所有的线程。这看起来是一个很方便的功能，但是它会遇到和`Thread.stop()`方法相同的问题，因此使用时也需要格外谨慎。

此外，对于编码习惯，我还想再多说几句。强烈建议大家在创建线程和线程组的时候，给它们取一个好听的名字。对于计算机来说，也许名字并不重要，但是在系统出现问题时，你很有可能会导出系统内所有线程，你拿到的如果是一连串的Thread-0、Thread-1、Thread-2，我想你一定会头疼。而你看到的如果是类似HttpHandler、FTPService这样的名字，则会心情倍爽。

## 二、守护线程 ##

守护线程是一种特殊的线程，就和它的名字一样，它是系统的守护者，在后台默默地完成一些系统性的服务，比如垃圾回收线程、JIT线程（即时编译编译器）就可以理解为守护线程。

与之相对应的是用户线程，用户线程可以认为是系统的工作线程，它会完成这个程序应该要完成的业务操作。如果用户线程全部结束，则意味着这个程序实际上无事可做了。守护线程要守护的对象已经不存在了，那么整个应用程序就应该结束。因此，当一个Java应用内只有守护线程时，Java虚拟机就会自然退出。

守护线程的使用：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 1]  
上述第16行代码将线程t设置为守护线程。这里注意，设置守护线程必须在线程`start()`之前设置，否则你会得到一个类似以下的异常，告诉你守护线程设置失败。但是你的程序和线程依然可以正常执行，只是被当作用户线程而已。因此，如果不小心忽略了下面的异常信息，你就很可能察觉不到这个错误，你就会诧异为什么程序永远停不下来了呢？

![在这里插入图片描述][20201116100644177.png_pic_center]  
在这个例子中，由于t被设置为守护线程，系统中只有主线程`main`为用户线程，因此在main线程休眠2秒后退出时，整个程序也随之结束。但如果不把线程t设置为守护线程，那么main线程结束后，t 线程还会不停地打印，永远不会结束。

## 三、线程优先级 ##

Java中的线程可以有自己的优先级。优先级高的线程在竞争资源时会更有优势，更可能抢占资源，当然，这只是一个概率问题。如果运气不好，那么高优先级线程可能也会抢占失败。由于线程的优先级调度和底层操作系统有密切的关系，在各个平台上表现不一，并且这种优先级产生的后果也可能不容易预测，无法精准控制，比如一个低优先级的线程可能一直抢占不到资源，从而始终无法运行，而产生饥饿（虽然优先级低，但是也不能饿死它呀）。因此，在要求严格的场合，还是需要自己在应用层解决线程调度问题。

在Java中，使用1到10表示线程优先级。一般可以使用内置的三个静态标量表示：

![在这里插入图片描述][2020111610094828.png_pic_center]  
数字越大则优先级越高，但有效范围在1到10之间，[具体示例可点击参考][Link 1]

## 四、线程安全的概念与关键字 synchronized ##

并行程序开发的一大关注重点就是线程安全。一般来说，程序并行化是为了获得更高的执行效率，但前提是，高效率不能以牺牲正确性为代价。如果程序并行化后，连基本的执行结果的正确性都无法保证，那么并行程序本身也就没有任何意义了。因此，线程安全就是并行程序的根基。大家还记得那个[多线程读写long型数据的案例][long] 它就是一个典型的反例。但在使用volatile关键字后，这种错误的情况有所改善。但是，volatile关键字并不能真正保证线程安全。它只能确保一个线程修改了数据后，其他线程能够看到这个改动。但当两个线程同时修改某一个数据时，依然会产生冲突。

关键字synchronized的作用是实现线程间的同步。它的工作是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性

synchronized 的其他知识可以参考：[一篇文章带你搞定 Java 中同步概念][Java]

关键字synchronized可以有多种用法，这里做一个简单的整理。

*  指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。
 *  直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
 *  直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

对于加锁对象和实例方法，示例中已经讲解了，关键这3个线程都指向同一个Runnable接口实例，这样才能保证三个线程在工作时，能够关注到同一个对象锁上去，从而保证线程安全。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 2]  
也可以使用 synchronize 的第三种用法，将其作用于静态方法，这样即使两个线程指向不同的Runnable 对象，但由于方法块需要请求的是当前类的锁，而非当前实例，因此，线程间还是可以正确同步。

class MyThread implements Runnable{ 
        private static int ticket = 5;
        @Override
        public void run(){ //覆写 run() 方法
            for(int i=0;i<100;i++){ 
                sale();
            }
        }
        public static synchronized void sale(){ //声明同步方法
            if(ticket>0){ 
                try{ 
                    Thread.sleep(10);
                }catch (InterruptedException e){ 
                    e.printStackTrace();
                }
                System.out.println("卖票：ticket = " + ticket--);
            }
        }
    }
    
    public class Test{ 
        public static void main(String[] args) { 
            MyThread mt1 = new MyThread();
            MyThread mt2 = new MyThread();
            Thread t1 = new Thread(mt1);
            Thread t2 = new Thread(mt2);
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][20201116103743745.png_pic_center]  
除了用于线程同步、确保线程安全外，关键字`synchronized`还可以保证线程间的可见性和有序性。从可见性的角度上讲，关键字`synchronized`可以完全替代关键字`volatile`的功能，只是使用上没有那么方便。就有序性而言，由于关键字`synchronized`限制每次只有一个线程可以访问同步块，因此，无论同步块内的代码如何被乱序执行，只要保证串行语义一致，那么执行结果总是一样的。而其他访问线程，又必须在获得锁后方能进入代码块读取数据，因此，它们看到的最终结果并不取决于代码的执行过程，有序性问题自然得到了解决（换言之，被关键字synchronized限制的多个线程是串行执行的）。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/ac6ec946d63c437bb7e20b68ae20352e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/afd2506ba20941cb9e9ec24d3727c019.png
[20201116100644177.png_pic_center]: /images/20221120/770ba5b79a1b4363b33e8b485351568c.png
[2020111610094828.png_pic_center]: /images/20221120/ca62e7f3a7dd4e3787314a2713882a05.png
[Link 1]: https://blog.csdn.net/nanhuaibeian/article/details/104011173
[long]: https://blog.csdn.net/nanhuaibeian/article/details/109697079
[Java]: https://blog.csdn.net/nanhuaibeian/article/details/104015479
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/2a395e96856c497387959082d817be49.png
[20201116103743745.png_pic_center]: /images/20221120/a35da138c699435f9f63943bdea92e5f.png