进程与线程

目录

 

 

1 基本概念

进程

进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

线程

线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

进程和线程的关系

线程是进程的一部分。一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程

进程和线程的区别

理解它们的差别，我从资源使用的角度出发。（所谓的资源就是计算机里的中央处理器，内存，文件，网络等等）

根本区别：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位

开销方面：每个进程都有独立的代码和数据空间（程序上下文），进程之间切换开销大；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小

所处环境：在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）

内存分配：系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源

包含关系：没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程

其他：

  1. 线程之间通信更方便，同一个进程下，线程共享全局变量，静态变量等数据；进程之间的通信需要以通信的方式（IPC）进行（但多线程程序处理好同步与互斥是个难点）。
  2. 多进程程序更安全，生命力更强，一个进程死掉不会对另一个进程造成影响（源于有独立的地址空间）；多线程程序更不易维护，一个线程死掉（非正常退出，死循环等），整个进程就死掉了（因为共享地址空间）；

一、线程的基本概念

1.1 单线程

简单的说，单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。

public class SingleThread {
    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            System.out.print(i + " ");
        }
    }
}

上述Java代码中，只有一个主线程执行main方法。

1.2 多线程

由一个以上线程组成的程序称为多线程程序。常见的多线程程序如：GUI应用程序、I/O操作、网络容器等。
Java中，一定是从主线程开始执行（main方法），然后在主线程的某个位置启动新的线程。

二、线程的基本操作

2.1 创建

Java中创建多线程类两种方法：

1、继承java.lang.Thread

public class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.print(i + " ");
        }
    }
}
public class MultiThread {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();    //启动子线程
        //主线程继续同时向下执行
        for (int i = 0; i < 10000; i++) {
            System.out.print(i + " ");
        }
    }
}

上述代码中，MyThread类继承了类java.lang.Thread，并覆写了run方法。主线程从main方法开始执行，当主线程执行至t.start()时，启动新线程（注意此处是调用start方法，不是run方法），新线程会并发执行自身的run方法。

2、实现java.lang.Runnable接口

public class MyThread implements Runnable {
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.print(i + " ");
        }
    }
}
public class MultiThread {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.start();    //启动子线程
        //主线程继续同时向下执行
        for (int i = 0; i < 10000; i++) {
            System.out.print(i + " ");
        }
    }
}

上述代码中，MyThread类实现了java.lang.Runnable接口，并覆写了run方法，其它与继承java.lang.Thread完全相同。实际上，java.lang.Thread类本身也实现了Runnable接口，只不过java.lang.Thread类的run方法主体里空的，通常被子类覆写（override）。

注意：主线程执行完成后，如果还有子线程正在执行，程序也不会结束。只有当所有线程都结束时（不含Daemon Thread），程序才会结束。

2.2 暂停

Java中线程的暂停是调用java.lang.Thread类的sleep方法（注意是类方法）。该方法会使当前正在执行的线程暂停指定的时间，如果线程持有锁，sleep方法结束前并不会释放该锁。

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.print(i + " ");
            try {
                Thread.sleep(1000);    //当前main线程暂停1000ms
            } catch (InterruptedException e) {
            }
        }
    }
}

上述代码中，当main线程调用Thread.sleep(1000)后，线程会被暂停，如果被interrupt，则会抛出InterruptedException异常。

2.3 互斥

Java中线程的共享互斥操作，会使用synchronized关键字。线程共享互斥的架构称为监视（monitor），而获取锁有时也称为“持有(own)监视”。

每个锁在同一时刻，只能由一个线程持有。

注意：synchronized方法或声明执行期间，如程序遇到任何异常或return，线程都会释放锁。

1、synchronized方法

Java示例1：

//synchronized实例方法
public synchronized void deposit(int m) {
    System.out.print("This is synchronized method.");
}

注：synchronized实例方法采用this锁（即当前对象）去做线程的共享互斥。

Java示例2：

//synchronized类方法
public static synchronized void deposit(int m) {
    System.out.print("This is synchronized static method.");
}

注：synchronized类方法采用类对象锁（即当前类的类对象）去做线程的共享互斥。如上述示例中，采用类.class（继承自 java.lang.Class）作为锁。

2、synchronized声明
Java示例：

public void deposit(int m) {
    synchronized (this) {
        System.out.print("This is synchronized statement with this lock.");
    }
    synchronized (Something.class) {
        System.out.print("This is synchronized statement with class lock.");
    }
}

注：synchronized声明可以采用任意锁，上述示例中，分别采用了对象锁（this）和类锁（something.class）

2.4 中断

java.lang.Thread类有一个interrupt方法，该方法直接对线程调用。当被interrupt的线程正在sleep或wait时，会抛出InterruptedException异常。
事实上，interrupt方法只是改变目标线程的中断状态（interrupt status），而那些会抛出InterruptedException异常的方法，如wait、sleep、join等，都是在方法内部不断地检查中断状态的值。

  • interrupt方法
    Thread实例方法：必须由其它线程获取被调用线程的实例后，进行调用。实际上，只是改变了被调用线程的内部中断状态；
  • Thread.interrupted方法
    Thread类方法：必须在当前执行线程内调用，该方法返回当前线程的内部中断状态，然后清除中断状态（置为false） ；
  • isInterrupted方法
    Thread实例方法：用来检查指定线程的中断状态。当线程为中断状态时，会返回true；否则返回false。

2.5 协调

1、wait set / wait方法
wait set是一个虚拟的概念，每个Java类的实例都有一个wait set，当对象执行wait方法时，当前线程就会暂停，并进入该对象的wait set。

当发生以下事件时，线程才会退出wait set：
①有其它线程以notify方法唤醒该线程
②有其它线程以notifyAll方法唤醒该线程
③有其它线程以interrupt方法唤醒该线程
④wait方法已到期

注：当前线程若要执行obj.wait()，则必须先获取该对象锁。当线程进入wait set后，就已经释放了该对象锁。

下图中线程A先获得对象锁，然后调用wait()方法（此时线程B无法获取锁，只能等待）。当线程A调用完wait()方法进入wait set后会自动释放锁，线程B获得锁。

2、notify方法

notify方法相当于从wait set中从挑出一个线程并唤醒。

下图中线程A在当前实例对象的wait set中等待，此时线程B必须拿到同一实例的对象锁，才能调用notify方法唤醒wait set中的任意一个线程。

注：线程B调用notify方法后，并不会立即释放锁，会有一段时间差。

3、notifyAll方法

notifyAll方法相当于将wait set中的所有线程都唤醒。

4、总结
wait、notify、notifyAll这三个方法都是java.lang.Object类的方法（注意，不是Thread类的方法）。
若线程没有拿到当前对象锁就直接调用对象的这些方法，都会抛出java.lang.IllegalMonitorStateException异常。

  • obj.wait()是把当前线程放到obj的wait set；
  • obj.notify()是从obj的wait set里唤醒1个线程；
  • obj.notifyAll()是唤醒所有在obj的wait set里的线程。

三、线程的状态转移

java线程在运行的生命周期中有六种不同的状态，在任意一个时间点，一个线程只能有且只有其中的一种状态 

1）New：初始状态，线程被创建，但是还没有调用start方法  

2）Runnable：java线程把操作系统中的就绪和运行都称为Runnable,处于该状态的线程可能正在运行也可能正在等待cpu为他分配执行时间。

3）Blocked：线程被锁阻塞  

4）Waiting ：等待状态，当前线程需要其他线程唤醒，处于这种状态的线程不会被分配cpu执行时间，要等待其他线程显示唤醒。以下方法会让线程进入无限期等待:

  • 1.没有设置timeout的object.wait()方法
  • 2.没有设置timeout参数的Thread.join()方法
  • 3.LockSupport.park();   

5）Time-Waiting：处于这种状态的线程也不会被分配cpu执行时间，不过无需等待被其他线程显示唤醒，而是在一定时间后，他们会由操作系统自动唤醒

  • 1.设置了timeout的object.at)
  • 2.设置了timeout参数的Thread.join()
  • 3.LockSupport.parkano()
  • 4.LockSupport.park.Unit()

6）Terminated ：当前线程已经执行完毕了 

 

线程的状态转移大致如下图：

    • 当创建一个Thread子类或实现Runnable接口类的实例时，线程进入【初始】状态；
    • 调用实例的start方法后，线程进入【可执行】状态；
    • 系统会在某一时刻自动调度处于【可执行】状态的线程，被调度的线程会调用run方法，进入【执行中】状态；
    • 线程执行完run方法后，进入【结束】状态；
    • 处于【结束】状态的线程，在某一时刻，会被JVM垃圾回收；
    • 处于【执行中】状态的线程，若调用了Thread.yield方法，会回到【可执行】状态，等待再次被调度；
    • 处于【执行中】状态的线程，若调用了wait方法，会进入wait set并一直等待，直到被其它线程通过notify、notifyAll、interrupt方法唤醒；
    • 处于【执行中】状态的线程，若调用了Thread.sleep方法，会进入【Sleep】状态，无法继续向下执行。当sleep时间结束或被interrupt时，会回到【可执行状态】；
    • 处于【执行中】状态的线程，若遇到阻塞I/O操作，也会停止等待I/O完成，然后回到【可执行状态】；

通信方式之间的差异

实际上只有进程间需要通信，同一进程的线程共享地址空间，没有通信的必要，但要做好同步/互斥,保护共享的全局变量。

而进程间通信无论是信号，管道pipe还是共享内存都是由操作系统保证的，是系统调用.

一、进程间的通信方式

  1. 无名管道( pipe )：  管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。所谓有亲缘关系，是指有同一个祖先。所以管道并不是只可以用于父子进程通信，也可以在兄弟进程之间还可以用在祖孙之间等；管道的本质是内核维护了一块缓冲区与管道文件相关联，对管道文件的操作，被内核转换成对这块缓冲区内存的操作。
  2. 命名管道 (FIFO) ：  有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。命名管道不同于无名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，这样，即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。
  3. 信号量(semophore ) ：  信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
  4. 消息队列( messagequeue ) ：  消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
  5. 信号 (sinal ) ：  信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生，接收到该信号的进程会执行相应的操作。信号是由操作系统处理的，所以信号的处理在内核态。如果不是紧急信号的话，它不一定被立即处理，操作系统不会为了处理一个信号而把当前正在运行的进程挂起，因为挂起（进程切换）当前进程消耗很大。所以操作系统一般会将信号先放入信号表中，一般选择在内核态切换回用户态的时候处理信号（不用自己单独进行进程切换以免浪费时间）。
  6. 共享内存(shared memory ) ：  共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。
  7. 套接字(socket ) ：  套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同设备及其间的进程通信。

二、线程间的通信方式

  1. 锁机制：包括互斥锁、条件变量、读写锁 
    • 互斥锁提供了以排他方式防止数据结构被并发修改的方法。
    • 读写锁允许多个线程同时读共享数据，而对写操作是互斥的。 
    • 条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。
  2. 信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量。
  3. 信号机制(Signal)：类似进程间的信号处理 
    • 线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。

推荐：


线程间的通信、同步方式与进程间通信方式： https://blog.csdn.net/qq_32621445/article/details/78635951
Linux内核解析:进程间通信：管道： https://www.cnblogs.com/zengyiwen/p/5755170.html
Linux进程间通信之消息队列: https://blog.csdn.net/wei_cheng18/article/details/79661495
进程间通信--信号： https://blog.csdn.net/ShWe_yayaya/article/details/81737848
进程间的通信—套接字(socket)：https://www.cnblogs.com/wanjianjun777/p/10483907.html

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

0

posted @ 2020-03-25 18:45  windy杨树  阅读(290)  评论(0)  编辑  收藏  举报