Java - 进程与线程

短命女 2022-05-30 03:59 263阅读 0赞

# 进程与线程 #

概述：几乎任何的操作系统都支持运行多个任务，通常一个任务就是一个程序，而一个程序就是一个进程。当一个进程运行时，内部可能包括多个顺序执行流，每个顺序执行流就是一个线程。

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

# 一、定义 #

## 1.1 进程 ##

**进程：**进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当程序进入内存运行时，即为进程。

其特点为：

1.  独立性：进程是系统中独立存在的实体，它可以独立拥有资源，每一个进程都有自己独立的地址空间，没有进程本身的运行，用户进程不可以直接访问其他进程的地址空间。
2.  动态性：进程和程序的区别在于进程是动态的，进程中有时间的概念，进程具有自己的生命周期和各种不同的状态。
3.  并发性：多个进程可以在单个处理器上并发执行，互不影响。
4.  异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进。

> 并发性和并行性是不同的概念：并行是指同一时刻，多个命令在多个处理器上同时执行；并发是指在同一时刻，只有一条命令是在处理器上执行的，但多个进程命令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果

因为进程在运行中会不断改变其运行状态。通常，一个运行进程具有以下三个基本状态：

1.  **就绪(Ready)状态：** 当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
2.  **执行（Running）状态：** 当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。
3.  **阻塞(Blocked)状态：** 正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。

![这里写图片描述][70]

> [处理机调度][Link 1]: 在多道程序设计系统中，内存中有多道程序运行，他们相互争夺处理机这一重要的资源。处理机调度就是从就绪队列中，按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程并发地执行。

## 1.2 线程 ##

**线程：**线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。

其特点为：

1.  线程可以完成一定任务，可以和其它线程共享父进程的共享变量和部分环境，相互协作来完成任务。
2.  线程是独立运行的，其不知道进程中是否还有其他线程存在。
3.  线程的执行是抢占式的，也就是说，当前执行的线程随时可能被挂起，以便运行另一个线程。
4.  一个线程可以创建或撤销另一个线程，一个进程中的多个线程可以并发执行。

在Java语言中，线程的状态被分为了如下的几个状态（`Thread.State`中定义的Enum名称）：`NEW`, `RUNNABLE`, `TERMINATED`, `WAITING`, `TIMED_WAITING`和`BLOCKED`。各个状态的值都可以通过Thread类的`getState()`方法获取。

下面两张图是Java线程的状态迁移图：  
![线程状态.png-310.6kB][.png-310.6kB]

![QQ截图20180304203812.png-128.5kB][QQ_20180304203812.png-128.5kB]

1.  **NEW**（新建）
2.  **RUNNABLE**（当线程正在运行或者已经就绪正等待 CPU 时间片）
3.  **BLOCKED**（阻塞，线程在等待获取对象同步锁）
4.  **Waiting**（调用不带超时的 wait() 或 join()）
5.  **TIMED\_WAITING**（调用 sleep()、带超时的 wait() 或者 join()）
6.  **TERMINATED**（死亡）

其中阻塞的情况分为三种：

1.  **等待阻塞：**运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，
2.  **同步阻塞：**运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。
3.  **其他阻塞：**运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

# 二、区别与联系 #

## 2.1 简化版本联系与区别 ##

### 2.1.1 联系 ###

1.  一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
2.  资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3.  处理机分给线程，即真正在处理机上运行的是线程。
4.  线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体。

### 2.1.2 区别 ###

1.  调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
2.  并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行。
3.  拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
4.  系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

## 2.2 详解版区别 ##

1.  **调度：**在传统的操作系统中，CPU调度和分派的基本单位是进程。而在引入线程的操作系统中，则把线程作为CPU调度和分派的基本单位，进程则作为资源拥有的基本单位，从而使传统进程的两个属性分开，线程编程轻装运行，这样可以显著地提高系统的并发性。同一进程中线程的切换不会引起进程切换，从而避免了昂贵的系统调用，但是在由一个进程中的线程切换到另一进程中的线程，依然会引起进程切换。
2.  **并发性：**在引入线程的操作系统中，不仅进程之间可以并发执行，而且在一个进程中的多个线程之间也可以并发执行，因而使操作系统具有更好的并发性，从而更有效地提高系统资源和系统的吞吐量。例如，在一个为引入线程的单CPU操作系统中，若仅设置一个文件服务进程，当它由于某种原因被封锁时，便没有其他的文件服务进程来提供服务。在引入线程的操作系统中，可以在一个文件服务进程设置多个服务线程。当第一个线程等待时，文件服务进程中的第二个线程可以继续运行；当第二个线程封锁时，第三个线程可以继续执行，从而显著地提高了文件服务的质量以及系统的吞吐量。
3.  **拥有资源：** 论是引入了线程的操作系统，还是传统的操作系统，进程都是拥有系统资源的一个独立单位，他可以拥有自己的资源。一般地说，线程自己不能拥有资源（也有一点必不可少的资源），但它可以访问其隶属进程的资源，亦即一个进程的代码段、数据段以及系统资源（如已打开的文件、I/O设备等），可供同一个进程的其他所有线程共享。
4.  **独立性：** 在同一进程中的不同线程之间的独立性要比不同进程之间的独立性低得多。这是因为  
    为防止进程之间彼此干扰和破坏，每个进程都拥有一个独立的地址空间和其它资源，除了共享全局变量外，不允许其它进程的访问。但是同一进程中的不同线程往往是为了提高并发性以及进行相互之间的合作而创建的，它们共享进程的内存地址空间和资源，如每个线程都可以访问它们所属进程地址空间中的所有地址，如一个线程的堆栈可以被其它线程读、写，甚至完全清除。
5.  **系统开销：** 由于在创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O设备等。因此，操作系统为此所付出的开销将显著地大于在创建或撤消线程时的开销。类似的，在进程切换时，涉及到整个当前进程CPU环境的保存环境的设置以及新被调度运行的CPU环境的设置，而线程切换只需保存和设置少量的寄存器的内容，并不涉及存储器管理方面的操作，可见，进程切换的开销也远大于线程切换的开销。此外，由于同一进程中的多个线程具有相同的地址空间，致使他们之间的同步和通信的实现也变得比较容易。在有的系统中，现成的切换、同步、和通信都无需操作系统内核的干预。
6.  **支持多处理机系统：** 在多处理机系统中，对于传统的进程，即单线程进程，不管有多少处理机，该进程只能运行在一个处理机上。但对于多线程进程，就可以将一个进程中的多个线程分配到多个处理机上，使它们并行执行，这无疑将加速进程的完成。因此，现代处理机OS都无一例外地引入了多线程。

# 三、 进程间通信的方式 #

## 3.1 管道（pipe）及有名管道（named pipe） ##

管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系；有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

## 3.2 信号（signal） ##

信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。

## 3.3 信号量（semaphore） ##

信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程之间及同一种进程的不同线程之间的同步和互斥手段。

## 3.4 消息队列（message queue） ##

消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。具有写权限的进程可以按照一定的规则向消息队列中添加新信息；对消息队列有读权限的进程则可以从消息队列中读取信息。

## 3.5 共享内存（shared memory） ##

以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据的更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的IPC方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。

## 3.6 套接字（socket） ##

这是一种更为一般的进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

# 四、线程间通信的方式 #

## 4.1 锁机制 ##

包括互斥锁、条件变量、读写锁：

*  互斥锁提供了以排他方式防止数据结构被并发修改的方法。
 *  读写锁允许多个线程同时读共享数据，而对写操作是互斥的。
 *  条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

## 4.2 信号量机制(Semaphore) ##

包括无名线程信号量和命名线程信号量。

## 4.3 信号机制(Signal) ##

类似进程间的信号处理。  
线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。

## 4.4 管道(Pipe) ##

示例代码如下：

package cn.edu.ujn.demo;
    
    import java.io.PipedReader;
    import java.io.PipedWriter;
    
    public class Piped {
    
        public static void main(String[] args) throws Exception{
            PipedWriter out = new PipedWriter();
            PipedReader in = new PipedReader();
            // 连接输入流和输出流，否则会报异常：java.io.IOException: Pipe not connected
            out.connect(in);
            Thread printThread = new Thread(new Print(in), "PrintThread");
            printThread.start();
            int receive = 0;
            try {
                while((receive = System.in.read()) != -1){
                    out.write(receive);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                out.close();
            }
        }
    
    }
    
    class Print implements Runnable{
        private PipedReader in;
    
        public Print(PipedReader in){
            this.in = in;
        }
    
        public void run(){
            int receive = 0;
            try {
                while((receive = in.read()) != -1){
                    System.out.print((char)receive);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

# 五、同步和互斥的区别 #

当有多个线程的时候，经常需要去同步这些线程以访问同一个数据或资源。例如，假设有一个程序，其中一个线程用于把文件写到内存，而另一个线程用于统计文件中的字符数。当然，在把整个文件调入内存之前，统计它的字符数是没有意义的。但是，由于每个操作都有自己的线程，操作系统会把两个线程当作是互不相干的任务分别执行，这样就可能在没有把整个文件装入内存时统计字符数。为解决此问题，你必须使两个线程同步工作。  
  所谓同步，是指散布在不同进程之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。如果用对资源的访问来定义的话，同步是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。  
  所谓互斥，是指散布在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。如果用对资源的访问来定义的话，互斥某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

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

参考资料：

1.  图解Java多线程设计模式： [http://www.ituring.com.cn/book/1812][http_www.ituring.com.cn_book_1812]
2.  [http://blog.csdn.net/sunhuaqiang1/article/details/52687518][http_blog.csdn.net_sunhuaqiang1_article_details_52687518]

[70]: /images/20220530/6a225c45547441848288096878301a22.png
[Link 1]: https://baike.baidu.com/item/%E5%A4%84%E7%90%86%E6%9C%BA%E8%B0%83%E5%BA%A6/6944303?fr=aladdin
[.png-310.6kB]: /images/20220530/409ead0a023e49c2bd86f4a0195dc4d3.png
[QQ_20180304203812.png-128.5kB]: /images/20220530/59007759554148d692e0e84c485bfb03.png
[http_www.ituring.com.cn_book_1812]: http://www.ituring.com.cn/book/1812
[http_blog.csdn.net_sunhuaqiang1_article_details_52687518]: http://blog.csdn.net/sunhuaqiang1/article/details/52687518