进程与线程

忘是亡心i 2021-09-07 06:19 608阅读 0赞

# 进程与线程 #

## 1 进程 ##

### 1.1 进程的概念 ###

进程就是正在运行的程序,它代表了程序所占用的内存区域

### 1.2 进程的特点 ###

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

### 1.3 并行和并发 ###

![并行与并发][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

> HA(High Availability)高可用:指在高并发的情景中,尽可能的保证程序的可用性,减少系统不能提供服务的时间

## 2 线程 ##

### 2.1 线程的概念 ###

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

### 2.2 进程与线程的关系 ###

一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)  
![进程与线程的关系][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 1]  
每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.  
所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成  
![进程与线程的关系][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 2]

## 3 多线程的特性 ##

### 3.1 随机性 ###

线程的随机性指的是同一时刻,只有一个程序在执行  
我们宏观上觉得这些程序像是同时运行,但是实际上微观时间是因为CPU在高效的切换着，这使得各个程序从表面上看是同时进行的,也就是说,宏观层面上,所有的进程/线程看似同时运行,但是微观层面上,同一时刻,一个CPU只能处理一件事.切换的速度甚至是纳秒级别的,非常快  
![线程切换][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 3]

### 3.2 CPU分时调度 ###

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

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

![CPU分片][CPU]

### 3.3 线程的状态 ###

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

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

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

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

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

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

### 3.4 线程状态与代码对照 ###

![线程状态与代码对照][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 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;
    /*本类用于多线程编程实现方案一*/
    public class TestThread1 { 
        public static void main(String[] args) { 
            //4.创建线程对象
            MyThread t = new MyThread();/*5.new对应的是线程的新建状态*/
            /*6.如果只是通过两个线程对象调用run(),那么会先执行完一个线程的任务 * 再执行另外一个线程的任务，根本不会以多线程的方式启动，所以就没有多线程抢占资源的效果*/
            //t.run();
            //5.模拟多线程，需要至少启动2个线程，如果只启动一个线程，就是单线程程序
            MyThread t2 = new MyThread();
            //t2.run();
            /*7.start()对应的状态是线程的就绪状态，至于什么时候执行，取决于什么时候被OS选中*/
            /*8.当我们调用start()启动线程时，底层虚拟机会自动调用run()执行我们的业务*/
            /*9.如果想让程序有多线程的效果，需要创建多个线程对象，并且调用start() * 将线程加入到就绪队列中才可以，调用run()只能当做普通的方法调用，没有多线程的效果*/
            /*10.线程执行的效果具有随机性，也就是说t1 t2 t3的执行结果是不可控制的 * 具体怎么执行，取决于CPU的调度，时间片的分配，我们控制不了*/
            t.start();
            t2.start();
            //7.创建一个自定义名称的线程对象并启动
            MyThread t3 = new MyThread("大连");
            t3.start();
        }
    }
    //1.自定义多线程类，然后让这个类继承Thread类
    /*1.方式一：通过继承的方式：extends Thread*/
    class MyThread extends Thread{ 
        /*11.为了修改线程的名称，不再使用系统自动分配的默认名称，可以提供一个含参构造 * 注意，给线程起名的功能实际是父类完成的，子类的构造函数只是调用了一下super(name);*/
        //6.添加自定义线程类的无参构造与含参构造
        public MyThread(){ //注意手动添加无参构造，否则无法不传参数创建线程对象
            super();
        }
        public MyThread(String name) { 
            super(name);
        }
    
        //2.重写run(),run()里写我们自己的业务
        @Override
        public void run() { 
            /*2.自定义线程类的业务需要写在重写的run()里 * 3.super.run()表示调用的是父类的业务，我们不用，所以注释掉*/
            //super.run();
            //3.写自己的业务：输出10次当前正在执行的线程的名称
            for (int i = 0; i < 10; i++) { 
                /*4.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;
    
    /**本类用于测试多线程编程方式2 implements Runnable*/
    public class Thread2 { 
    	public static void main(String[] args) { 
    		//4.创建线程对象
    		MyRunnable target = new MyRunnable();
    		//5.2 问题:怎么把接口的实现类和Thread类绑定
    		Thread thread1 = new Thread(target);
    		
    		//5.1如何启动线程?
    		thread1.start();
    		
    		//6.--以多线程编程的方式启动,需要创建多个线程对象并启动
    		//8.修改线程的名称--使用Thread类的含参构造
    		Thread thread2 = new Thread(target,"杰克");
    		Thread thread3 = new Thread(target,"露丝");
    		thread2.start();
    		thread3.start();
    		
    		//7.自己测试start()和run()的区别
    		//run()只是一个普通方法执行的效果,也就是单线程顺序执行的效果,没有多线程的线现象
    	}
    }
    
    //1.自定义多线程类,方式2 implements Runnable
    class MyRunnable implements Runnable{ 
    
    	//2.把业务放入run(),重写了Runnable接口里的
    	@Override
    	public void run() { 
    		//3.写业务,打印10次线程名称
    		for(int i = 0; i< 10; i++){ 
    			//问题:Runnable接口中,没有提供多余的方法维度只有一个run()
    			//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张*/
    /*本类通过继承Thread类的方式实现多线程售票案例*/
    public class TestThread { 
        public static void main(String[] args) { 
            //5.创建多个线程对象 Ctrl+D 复制当前行
            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.自定义线程售票业务类
    class TicketThread extends Thread{ 
        //3.定义变量,用来保存票数
        //int tickets = 100;//不可以,会卖400张票
        //7.解决4个线程卖了400张票的BUG
        static int tickets = 100;//静态资源属于类资源,被全局所有对象共享,只有一份
        //2.把业务写在重写run()里
        @Override
        public void run() { 
            //4.通过循环结构来一直卖票
            while (true){ 
                try { 
                    //8.如果数据能够经受住sleep的考验,才能说明数据没有了安全隐患--人为制造问题
                    //问题1:产生了重卖:同一张票卖给了多个人
                    //问题2:产生了超卖:超出了规定票数,甚至卖出了0和-1这样的票数
                    Thread.sleep(10);//让程序休眠10ms
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(getName()+"="+tickets--);
                //做判断,如果没有票了,就退出死循环
                if(tickets <= 0) break;//注意,死循环一定要设置出口
            }
        }
    }

### 6.2 方案2：实现Runnable ###

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

package cn.tedu.tickets;
    /*需求:设计多线程编程模型,4个窗口共计售票100张*/
    /*本类通过实现Runnable接口的方式实现多线程售票案例*/
    public class TestRunnable { 
        public static void main(String[] args) { 
            //5.创建目标业务对象
            TicketRunnable target = new TicketRunnable();
            //6.使用Thread类中的含参构造,将目标对象与线程对象做绑定
            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.创建自定义多线程类
    class TicketRunnable implements Runnable{ 
        //3.创建成员变量,用来保存票数,注意必须是静态的
        static int tickets = 100;
        //2.添加接口中未实现的方法,把业务放在run()里
        @Override
        public void run() { 
            while (true){ 
                try { 
                    //让程序休眠后出现的两个问题:
                    //问题1.重卖:一张票卖给了多个人
                    //问题2.超卖:出现了票数为0甚至是负数的情况
                    Thread.sleep(10);//让程序休眠10ms
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                //3.获取当前正在卖票的线程名称,以及卖票
                System.out.println(Thread.currentThread().getName()+"="+tickets--);
                //4.设置死循环的出口
                if (tickets <= 0) break;
            }
        }
    }

### 6.3 问题 ###

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/110b2411901a45c59f65fab25c9ed572.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 1]: /images/20210827/b306b0a332844117b8351aa4d0c1a5df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 2]: /images/20210827/d7fc053c351c4a23a1595e4bf0fc6271.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 3]: /images/20210827/8b49ded9a7594ba3992310d5767425d3.png
[CPU]: /images/20210827/e39194fb151b4e3881e859329105b8a5.png
[3]: /images/20210827/50d4d66147494536b83c88fd5e787de8.png
[5]: /images/20210827/32b9d5caa28746bb99976befb1270460.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 4]: /images/20210827/bb86fdee4d1d476389654bdaac4c1979.png
[Link 1]: https://blog.csdn.net/weixin_43884234/article/details/115049704