多线程并行并发以及生产者消费者问题

你的名字 2022-01-21 06:49 208阅读 0赞

### 目录 ###

*  什么是并行和并发？
 *  什么是线程和进程
 *  什么是线调度？
 *  多线程的好处？
 *  线程中的常用方法
 *  线程的状态
 *  什么是等待唤醒机制
 *   *  线程间通信
     *  等待唤醒机制
     *  生产者与消费者问题
 *  什么是线程池
 *   *  线程池概念
     *  线程池的使用

# 什么是并行和并发？ #

>  *  并发：指两个或多个事件在同一个时间段内发生。
>  *  并行：指两个或多个事件在同一时刻发生（同时发生）。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70]  
**并发就是交替使用cpu执行权，并行就是有多个cpu，不会发生cpu抢占，多个程序同时运行。**

# 什么是线程和进程 #

>  *  进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

**重点：进入到内存中的程序。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 1]

>  *  线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 2]  
**主线程：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 3]

*  简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

# 什么是线调度？ #

>  *  分时调度所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
>  *  抢占式调度优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

*  设置线程的优先级  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 4]
 *  抢占式调度详解

> 大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而  
> CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。  
> 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高

# 多线程的好处？ #

> **在不同栈空间，线程之间互不影响。创建线程之后开启start方法，就会自动开辟一个占空间。**

# 线程中的常用方法 #

![在这里插入图片描述][201906081607004.png]  
![在这里插入图片描述][20190608160732269.png]

# 线程的状态 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 6]

# 什么是等待唤醒机制 #

## 线程间通信 ##

**概念**：

> 多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。  
> 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 7]  
**为什么要处理线程间通信：**

> 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行,  
> 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

**如何保证线程间通信有效利用资源：**

> 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时，  
> 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制

## 等待唤醒机制 ##

**什么是等待唤醒机制**

> 这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

> 就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后  
> 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用  
> notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

**等待唤醒中的方法**

> 1.  wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时 的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象 上等待的线程从wait set  
>     中释放出来，重新进入到调度队列（ready queue）中
> 2.  notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先 入座。
> 3.  notifyAll：则释放所通知对象的 wait set 上的全部线程。

**调用wait和notify方法需要注意的细节**

> 1.  wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
> 2.  wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。
> 3.  wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

## 生产者与消费者问题 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 8]  
**代码演示**  
**包子类**

public class BaoZi { 
    	String xianr;
    	String pier;
    	boolean flag = false;// 包子状态判断
    }

**吃货线程类**

public class ChiHuo extends Thread{ 
         private BaoZi baozi;
         private String name;
         public ChiHuo(String name,BaoZi baozi) { 
    		this.name=name;
    		this.baozi=baozi;
    	}
         @Override
        public void run() { 
        	// TODO Auto-generated method stub
        	while(true) { 
        		synchronized (baozi) { 
    				if(baozi.flag==false) { //没包子就不吃了
    					try { 
    						baozi.wait();
    					} catch (InterruptedException e) { 
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    				System.out.println("吃货"+name+"正在吃"+baozi.xianr+baozi.pier+"味的包子！");
    				baozi.flag=false;//吃完包子了。
    				baozi.notify();//唤醒同一个锁对象的线程
    			}
        	}
        }
    }

**包子铺线程类**

package com.xlh.waitandnotify;
    
    public class BaoZiPu extends Thread { 
    	private BaoZi baozi;
    	private String name;
    
    	public BaoZiPu(String name, BaoZi baozi) { 
    		this.name = name;
    		this.baozi = baozi;
    	}
    	@Override
    	public void run() { 
    		// TODO Auto-generated method stub
    		int count = 0;
    		//造包子
    		while(true) { 
    			synchronized (baozi) { 
    				if(baozi.flag==true) { //有包子就不生产
    					try { 
    						baozi.wait();
    					} catch (InterruptedException e) { 
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    				System.out.println("包子铺"+name+"正在造包子");
    				if(count%2==0) { 
    					baozi.pier="厚皮";
    					baozi.xianr="牛肉";		
    				}else { 
    					baozi.pier = "薄皮";
    					baozi.xianr = "韭菜鸡蛋";
    				}
    				count++;
    				baozi.flag=true;
    				System.out.println("包子铺"+name+"造好了:"+baozi.pier+baozi.xianr+"包子");
    				System.out.println("吃货来吃吧");
    				baozi.notify();
    			}
    		}
    	}
    }

**测试类**、

public class Test {
    	public static void main(String[] args) {
    		BaoZi baozi = new BaoZi();
    		ChiHuo ch = new ChiHuo("张三",baozi);
    		BaoZiPu bzp = new BaoZiPu("老台门", baozi);
    		ch.start();
    		bzp.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 9]  
**重点，使用同步锁，同步锁要使用一个锁对象。**

# 什么是线程池 #

## 线程池概念 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 10]  
**合理利用线程池能够带来三个好处：**

1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
    2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
    3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内
    存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

## 线程池的使用 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][20190608202930828.png]  
**Runable实现类代码**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 12]  
**线程池测试类：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 13]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70]: /images/20220121/a990e22c16d44646895422b097c8be8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 1]: /images/20220121/b2e04f37c8ec4ce7b81c6aeb855b86cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 2]: /images/20220121/9709a2bf7723429b9be3b7f13810e9de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 3]: /images/20220121/a96cf69883714f17b3e46c9908b939ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 4]: /images/20220121/600b9a664dae40bca252bba149107edc.png
[201906081607004.png]: /images/20220121/e4d79d6dccad4efc8de202dcf1575f03.png
[20190608160732269.png]: /images/20220121/a8488d0d6b6a4cc98507abe57d8016fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 5]: /images/20220121/eb02dd9208554304aec2b6a1ca206575.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 6]: /images/20220121/3c65c3906ae94539889a87ce75496620.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 7]: /images/20220121/f6cc0cf0f1d648169eea6d317d71902e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 8]: /images/20220121/54d92e0a9cc441e78f5462a09b134c86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 9]: /images/20220121/a2dffa3c633b42509befeff1e0a6874a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 10]: /images/20220121/232f7ebcaea04f44a073efaeb9722c36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 11]: /images/20220121/10d11529ce634124896bf60b80367b02.png
[20190608202930828.png]: /images/20220121/67b093cd50c14a4daf83bb468a29a433.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 12]: /images/20220121/a32a7b8eea894c61beb1f035b2c8a8e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDA1NjY2_size_16_color_FFFFFF_t_70 13]: /images/20220121/b1317499ad07418e91d0552e1f34a520.png