进程与线程

1 进程

1.1 进程的概念

进程就是正在运行的程序,它会占用对应的内存区域，由CPU进行执行与计算。

1.2 进程的特点

• 独立性
  进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
• 动态性
  进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的.
• 并发性
  多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响.

2 线程

2.1 线程的概念

线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.
一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程。
我们看到的进程的切换，切换的也是不同进程的主线程
多线程可以让同一个进程同时并发处理多个任务，相当于扩展了进程的功能。

2.2 进程与线程的关系

一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)

每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.
所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成

3 多线程的特性

3.1 随机性

我们宏观上觉得多个进程是同时运行的,但实际的微观层面上，一个CPU【单核】只能执行一个进程中的一个线程。
那为什么看起来像是多个进程同时执行呢？
是因为CPU以纳秒级别甚至是更快的速度高效切换着，超过了人的反应速度，这使得各个进程从看起来是同时进行的,也就是说,宏观层面上,所有的进程看似并行【同时运行】,但是微观层面上是串行的【同一时刻,一个CPU只能处理一件事】。

串行与并行

串行是指同一时刻一个CPU只能处理一件事，类似于单车道
并行是指同一时刻多个CPU可以处理多件事，类似于多车道

3.2 CPU分时调度

时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间，如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起,如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,当再次切换到之前挂起的线程,恢复现场,继续执行。
注意:我们无法控制OS选择执行哪些线程,OS底层有自己规则,如:

1. FCFS(First Come First Service 先来先服务算法)
2. SJS(Short Job Service短服务算法)

3.3 线程的状态

由于线程状态比较复杂,我们由易到难,先学习线程的三种基础状态及其转换,简称”三态模型” :

• 就绪(可运行)状态：线程已经准备好运行，只要获得CPU，就可立即执行
• 执行(运行)状态：线程已经获得CPU，其程序正在运行的状态
• 阻塞状态：正在运行的线程由于某些事件（I/O请求等）暂时无法执行的状态，即线程执行阻塞
  

就绪 → 执行:为就绪线程分配CPU即可变为执行状态"
执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态
执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞
(例如线程正在访问临界资源,而资源正在被其他线程访问)
反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行

我们可以再添加两种状态:

• 创建状态:线程的创建比较复杂,需要先申请PCB,然后为该线程运行分配必须的资源,并将该线程转为就绪状态插入到就绪队列中
• 终止状态:等待OS进行善后处理,最后将PCB清零,并将PCB返回给系统
  

PCB(Process Control Block):为了保证参与并发执行的每个线程都能独立运行,OS配置了特有的数据结构PCB来描述线程的基本情况和活动过程,进而控制和管理线程

3.4 线程状态与代码对照

线程生命周期,主要有五种状态:

1. 新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
2. 就绪状态(Runnable):当调用线程对象的start()方法,线程即为进入就绪状态.
   处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
3. 运行状态(Running):当CPU调度了处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态
   就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
4. 阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.
   根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:
   等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
   同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
   其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
5. 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期

4 多线程代码创建方式1:继承Thread

4.1 概述

Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例
启动线程的唯一方法就是通过Thread类的start()实例方法
start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()
这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法
模拟开启多个线程,每个线程调用run()方法.

4.2 常用方法

构造方法

Thread() 分配新的Thread对象
Thread(String name) 分配新的Thread对象
Thread(Runnable target) 分配新的Thread对象
Thread(Runnable target,String name) 分配新的Thread对象

普通方法

static Thread currentThread( )
返回对当前正在执行的线程对象的引用
long getId()
返回该线程的标识
String getName()
返回该线程的名称
void run()
如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法
static void sleep(long millions)
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
void start()
使该线程开始执行:Java虚拟机调用该线程的run()

4.3 测试多线程的创建方式1

创建包: cn.tedu.thread
创建类: TestThread1.java

package cn.tedu.thread;
/*本类用于多线程编程实现方案一：继承Thread类来完成*/
public class TestThread1 {
    public static void main(String[] args) {
        //4.创建线程对象进行测试
        /*4.new对应的是线程的新建状态
        * 5.要想模拟多线程，至少得启动2个线程，如果只启动1个，是单线程程序*/
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();
        /*6.这个run()如果直接这样调用，是没有多线程抢占执行的效果的
        * 只是把这两句话看作普通方法的调用，谁先写，就先执行谁*/
        //t1.run();
        //t2.run();
        /*7.start()对应的状态就是就绪状态，会把刚刚新建好的线程加入到就绪队列之中
        * 至于什么时候执行，就是多线程执行的效果，需要等待OS选中分配CPU
        * 8.执行的时候start()底层会自动调用我们重写的run()种的业务
        * 9.线程的执行具有随机性，也就是说t1-t4具体怎么执行
        * 取决于CPU的调度时间片的分配，我们是决定不了的*/
        t1.start();//以多线程的方式启动线程1，将当前线程变为就绪状态
        t2.start();//以多线程的方式启动线程2，将当前线程变为就绪状态
        t3.start();//以多线程的方式启动线程3，将当前线程变为就绪状态
        t4.start();//以多线程的方式启动线程4，将当前线程变为就绪状态
    }
}

//1.自定义一个多线程类，然后让这个类继承Thread
class MyThread extends Thread{
    /*1.多线程编程实现的方案1：通过继承Thread类并重写run()来完成的 */
    //2.重写run(),run()里是我们自己的业务
    @Override
    public void run() {
        /*2.super.run()表示的是调用父类的业务，我们现在要用自己的业务，所以注释掉*/
        //super.run();
        //3.完成业务：打印10次当前正在执行的线程的名称
        for (int i = 0; i < 10; i++) {
            /*3.getName()表示可以获取当前正在执行的线程名称
            * 由于本类继承了Thread类，所以可以直接使用这个方法*/
            System.out.println(i+"="+getName());
        }
    }
}

5 多线程代码创建方式2:实现Runnable接口

5.1 概述

如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口

5.2 常用方法

void run()使用实现接口Runnable的对象创建线程时,启动该线程将导致在独立执行的线程中调用对象的run()方法

5.3 练习2：测试多线程的创建方式2

创建包: cn.tedu.thread
创建类: Thread2.java

package cn.tedu.thread;
/*本类用于多线程编程实现方案二：实现Runnable接口来完成*/
public class TestThread2 {
    public static void main(String[] args) {
        //5.创建自定义类的对象--目标业务类对象
        MyRunnable target = new MyRunnable();
        //6.如何启动线程？自己没有，需要与Thread建立关系
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程类
class MyRunnable implements Runnable{
    //2.添加父接口中的抽象方法run(),里面是自己的业务
    @Override
    public void run() {
        //3.写业务，打印10次当前正在执行的线程名称
        for (int i = 0; i < 10; i++) {
            /*问题：自定义类与父接口Runnable中都没有获取名字的方法
            * 所以还需要从Thread中找：
            * currentThread():静态方法，获取当前正在执行的线程对象
            * getName():获取当前线程的名称*/
            System.out.println(i+"="+Thread.currentThread().getName());
        }
    }
}

5.4 两种实现方式的比较

• 继承Thread类
  优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程
  缺点: 自定义的线程类已继承了Thread类,所以后续无法再继承其他的类
• 实现Runnable接口
  优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类,在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想
  缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法

6 售票案例

需求:设计4个售票窗口，总计售票100张。用多线程的程序设计并写出代码

6.1 方案1：继承Thread

创建包: cn.tedu.tickets
创建类: TestThread.java

package cn.tedu.tickets;
/*需求：设计多线程编程模型，4个窗口共计售票100张
* 本方案使用多线程编程方案1，继承Thread类的方式来完成*/
public class TestThread {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程售票类，继承Thread
class TicketThread extends Thread{
    //3.定义变量，保存要售卖的票数
    /*问题：4个线程对象共计售票400张，原因是创建了4次对象，各自操作各自的成员变量
    * 解决：让所有对象共享同一个数据，票数需要设置为静态*/
    static int tickets = 100;
    //2.重写父类的run(),里面是我们的业务
    @Override
    public void run() {
        //4.1循环卖票
        while(true){
            try {
                //7.让每个线程经历休眠，增加线程状态切换的频率与出错的概率
                //问题1：产生了重卖的现象：同一张票卖了多个人
                //问题2：产生了超卖的现象：超出了规定的票数100，出现了0 -1 -2这样的票
                Thread.sleep(10);//让当前线程休眠10ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //4.2打印当前正在卖票的线程名称，并且票数-1
            System.out.println(getName()+"="+tickets--);
            //4.3做判断，如果没有票了，就退出死循环
            if(tickets <= 0) break;//注意，死循环一定要设置出口
        }
    }
}

6.2 方案2：实现Runnable

创建包: cn.tedu.tickets
创建类: TestRunnable.java

package cn.tedu.tickets;
/*需求：设计多线程编程模型，4个窗口共计售票100张
 * 本方案使用多线程编程方案2，实现Runnable接口的方式来完成*/
public class TestRunnable {
    public static void main(String[] args) {
        //5.创建Runnable接口的实现类对象，作为目标业务对象
        TicketRunnable target = new TicketRunnable();
        //6.创建多个Thread类线程对象，并将target业务对象交给多个线程对象来处理
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        //7.以多线程的方式启动多个线程对象
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程类实现Runnable接口
class TicketRunnable implements Runnable{
    //3.定义一个成员变量，用来保存票数100
    /*由于自定义类对象只创建了一次，所以票数被所有线程对象Thread类的对象共享*/
    int tickets = 100;
    //2.添加接口中未实现的方法，方法里是我们的业务
    @Override
    public void run() {
        //4.1循环卖票
        while(true){
            //8.让线程休眠10ms,增加线程状态切换的概率和出错的概率
            try {
                Thread.sleep(10);//让当前线程休眠10ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //4.2打印当前正在售票的线程名称 & 票数-1
            System.out.println(Thread.currentThread().getName()+"="+tickets--);
            //4.3设置死循环的出口，没票了就停止卖票
            if(tickets <=0 ) break;
        }
    }
}

6.3 问题

1. 每次创建线程对象，都会生成一个tickets变量值是100，创建4次对象就生成了400张票了。不符合需求，怎么解决呢？能不能把tickets变量在每个对象间共享，就保证多少个对象都是卖这100张票。
   解决方案: 用静态修饰
2. 产生超卖，0 张 、-1张、-2张。
3. 产生重卖，同一张票卖给多人。
4. 多线程安全问题是如何出现的？常见情况是由于线程的随机性+访问延迟。
5. 以后如何判断程序有没有线程安全问题？
   在多线程程序中 + 有共享数据 + 多条语句操作共享数据
   解决方案:下一节 同步锁点这里

目录

进程

线程

1.进程池

2.使用线程

使用线程的好处

为啥线程要比进程轻量呢？

线程与进程的区别与联系

---

进程

上节我们写了有关进程的相关知识，这节我们来说下线程及他与进程的区别与联系，有没看过的可以先点击链接跳转

Java 进程_Xiillldddd的博客-CSDN博客

线程

什么是线程呢？

首先面对这个问题我们先来说说进程是用来干啥的？

答案是因为现在的系统支持多任务了，而程序员自然也需要“并发编程”，当我们通过进程自然而然可以实现并发编程，但是存在一个小问题，就是我们需要不断地创建/销毁进程，而这些步骤的开销是非常大的，而频繁调度进程，这个事情的成本也很高，那么，怎么办呢？

接下来有两种方法供我们选择

1.进程池

进程池虽然能解决上述问题，并且提高效率，但是，这也存在问题，就是池子里的闲置进程，不使用的时候也在消耗资源，并且消耗资源很多，那么我们只能考虑第二个办法了，那就是使用线程来实现并发编程。

2.使用线程

线程比进程更加轻量， 每个进程实现一个任务，每个线程也能执行一个任务，也能够实现并发编程。

使用线程的好处

1.创建线程的成本比创建进程的成本低好多。

2.销毁线程的成本也比销毁进程的成本低很多。

3.调度线程的成本也比调度进程的成本低很多

总的来说，线程就像是轻量级的进程，而在Linux上也把线程称为轻量级进程。

为啥线程要比进程轻量呢？

首先我们来想想，进程重在哪呢？ 进程重在资源的申请和释放（就像是在偌大的仓库里找东西）

而线程是包含在进程中的，一个进程能拥有多个线程，共享一份资源，当我们在进程中创建线程的时候，只是第一份线程成本相对较高，后续当我们再在这个进程中创建线程的时候，这个时候成本都是要更低一些，不必再分配资源了。

那接下来，我们进入主题，来谈谈并总结线程与进程的区别与联系！！

线程与进程的区别与联系

1.进程里面包含线程，一个进程可以有多个线程，也可以只有一个线程。

2.进程和线程都是为了处理并发编程这样的场景。但是进程存在创建销毁调度消耗资源比较大的问题，相比之下，线程更加轻便，效率更加的搞。

3.操作系统创建进程要给他分配资源，进程是操作系统调度执行的基本单位。

4.进程具有独立性，每个进程有各自的虚拟空间，彼此之间不会相互影响，但是一个进程中有多个线程公用一个内存空间，当一个线程出现问题，其他的线程很大可能受到影响，甚至导致整个进程崩溃。

进程

计算机的核心是CPU，它承担了所有的计算任务，而操作系统是计算机的管理者，它负责任务的调度，资源的分配和管理，
统领整个计算机硬件；应用程序是具有某种功能的程序，程序是运行于操作系统之上的。

进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序，数据集合和进程控制块三部分组成。

程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块包含进程的描述信息和控制信息是进程存在的唯一标志

进程具有的特征：

动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的。

并发性：任何进程都可以同其他进行一起并发执行。

独立性：进程是系统进行资源分配和调度的一个独立单位。

结构性：进程由程序，数据和进程控制块三部分组成。

线程

在早期的操作系统中并没有线程的概念，进程是拥有资源和独立运行的最小单位，也是程序执行的最小单位。任务调度采用的是时间片

轮转的抢占式调度方式，而进程是任务调度的最小单位，每个进程有各自独立的一块内存，使得各个进
程之间内存地址相互隔离。后来，随着计算机的发展，对CPU的要求越来越高，进程之间的切换开销较大，已经无法满足越来越复杂的程序的要求了。于是就发明

了线程，线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。一个进程可以有一个或

多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。一个标准的线程由线程ID，当前指令指针PC，寄存器和堆栈组

成。而进程由内存空间(代码，数据，进程空间，打开的文件)和一个或多个线程组成。

进程与线程的区别

1. 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位。

2. 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线。

3. 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信号等)，某进程内的线程在其他进程不可见。

4. 调度和切换：线程上下文切换比进程上下文切换要快得多。