Java并发编程1：进程与线程概述

进程和线程

在学习Java并发编程的过程中，往往涉及多线程的问题。说到多线程，就要先明确进程和线程的概念。

进程

在操作系统中，进程被定义为程序在一个数据集合上运行的过程，是系统进行资源分配和调度的一个独立单位。

说白了就是受操作系统管理的基本运行单元。打开我们的任务管理器，现在正在运行的chrome、金山PDF等都可以理解为一个进程。

进程与程序的区别

①进程是主动的(active)、动态的，强调执行过程，它动态地创建，并被调度执行后消亡；程序是被动的(passive)、静态的，是指令的有序集合，没有任何执行的含义。

②进程是暂时的，是一个状态变化的过程；程序是永久的，可长久保存。

③进程与程序的组成不同：进程的组成包括程序。

④进程与程序的对应关系：通过多次执行，一个程序可对应多个进程；通过调用关系，一个进程可包括多个程序。

进程的基本特征

①动态性：进程是程序的一次执行过程，是动态的，即有生命周期。因创建而产生，因调度而执行，因得不到资源而暂停执行，最后由撤销而消亡。

②并发行：引入进程的目的，是为了多个进程可同时存在于系统中并可以并发执行，以提高资源利用率。

③独立性：进程是系统中独立运行的基本单位，也是系统中可独立获得资源和独立调度的基本单位。

④异步性：系统中各个进程按各自独立、不可预知的速度向前推进，这将导致程序的不可再现性（结果不确定）。

⑤结构特征：为了方便系统对进程进行管理和控制，采用PCB（进程控制块）对进程进行描述。从结构上看，进程由程序段、数据段、程序控制块(PCB)三部分构成。

进程的状态转换

在操作系统中，进程的基本状态转换如下图所示：

·引起进程状态转换的原因：

①处理机调度

②进程在运行过程中需要等待某一事件

③进程所等待的事件发生

·挂起状态的引入：

进程由内存调到外存，进入挂起状态。主要有以下几个原因：

①终端用户的请求

②父进程请求

③负荷调节的需要

④操作系统的需要

线程

操作系统中，进程是一个资源拥有者，在创建、撤销、切换、调度时系统开销较大，使系统中进程数有限，这将影响进程并发度。引入线程，是为了减少程序并发执行时所付出的时空开销，使操作系统具有更好的并发性，以改善资源利用率及提高系统吞吐量。

线程是进程内一个相对独立的、可调度的执行单元，就相当于进程中的一个子任务。比如当使用微信时，就有很多子任务在运行，聊天、视频、文件上传下载等。

线程的状态和控制

①线程创建

进程创建时也创建了该进程内的线程。随后进程内的线程又可创建另外的线程，为新线程设定指令指针和参数，提供寄存器上下文和栈空间，并将其放入就绪队列。

②线程阻塞

当一个线程需要等待一个事件，将被阻塞。在保护相关现场后，处理机可以去执行其他的就绪线程。

③线程解除阻塞

当线程等待的事件发生后，可解除原来的阻塞状态，将其移至就绪队列中

④线程终止

当线程完成后，释放它占用的寄存器上下文和栈空间

线程与进程的关系

进程是系统中资源分配的基本单位。一个进程由多个线程构成，这些线程共享该进程的系统资源。

两者比较：

①调度

同一进程的多线程间调度时，不引起进程的切换；

不同进程的线程间调度，需要进程切换

②并发行

一个进程的多个线程之间可并发执行

③资源的拥有

线程不拥有系统资源、代码段、数据段等

④系统开销

线程：系统仅为其保存少量寄存器内容

进程：整个当前CPU环境

⑤安全性

同一进程的多线程共享所有资源。一个错误的线程可以改变另一个线程使用的数据而导致错误发生。采用多进程的系统中，系统不允许一个进程有意或无意地破坏另一个进程。从安全性角度，使用多进程比多线程可能更安全。

Java创建线程的方式

Java创建线程的方式有两种：1.继承Thread，重写父类的run()方法 2.实现Runnable接口。

①继承Thread，重写run()方法

/**
 * 创建一个子线程，完成1-100之间自然数的输出。同样地，主线程执行同样的操作。
 * 创建多线程的第一种方式：继承java.lang.Thread类
 * Created by Wavy on 2018/4/17.
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
    //2.重写Thread类的run()方法
    public void run(){
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        //3.创建一个子类的对象
        SubThread st = new SubThread();
        //4.调用线程的start()，启动此线程；调用相应的run()方法
        //5.一个线程只能执行一次start()
        //6.不能通过Thread实现类对象的run()去启动一个线程
        //st.run();
        st.start();

        //主线程执行的内容
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

②实现Runnable接口

/**
 * 创建多线程的方式二：通过实现的方式
 *
 * Created by Wavy on 2018/4/17.
 */
//1.创建一个实现Runnable接口的类
class PrintNum1 implements Runnable{
    //2.实现接口的抽象方法
   public void run(){
       for(int i=1;i<=100;i++){
           if(i%2==0)
               System.out.println(Thread.currentThread().getName()+":"+i);
       }
   }
}
public class TestThread2 {
    public static void main(String[] args){
        //3.创建一个Runnable接口实现类的对象
        PrintNum1 p = new PrintNum1();
        //4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
        Thread t = new Thread(p);
        //5.调用start()方法，启动线程并执行run()方法
        t.start();

        //再创建一个线程
        Thread t2 = new Thread(p);
        t2.start();
    }
}

比较继承方式和实现方式：

①联系：Thread类也实现了Runnable接口。

②实现的方式优于继承的方式：

1.实现方式避免了java单继承的局限性。

2.实现的方式比继承的方式更有利于减少程序之间的耦合。

3.如果多个线程要操作共享数据，使用实现的方式更合适。因为当使用继承方式时，需要将共享数据设置为static，只有当其所属的类作用结束时，才会从内存中清除掉。以窗口售票为例，举例如下：

>继承的方式

/**
 * 模拟火车站售票窗口，开启三个窗口售票，总票数为100张
 * Created by Wavy on 2018/4/17.
 */
class Window1 extends Thread{
    //需要将ticket设置成静态的
    static int ticket = 100;
    public void run(){
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()
                        +"售票，票号为："+ticket--);
            }else{
                break;
            }
        }
    }
}
public class TestWindow1 {
    public static void main(String[] args){
        Window1 w1 = new Window1();
        Window1 w2 = new Window1();
        Window1 w3 = new Window1();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

>实现的方式

/**
 * 模拟火车站售票窗口，开启三个窗口售票，总票数为100张
 * Created by Wavy on 2018/4/17.
 */
class Window implements Runnable{
    int ticket = 100;
    public void run(){
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()
                +"售票，票号为："+ticket--);
            }else {
                break;
            }
        }
    }
}
public class TestWindow {
    public static void main(String[] args){
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}