Java并发编程

东皇太乙

于 2020-11-21 13:21:35 发布

阅读量184

点赞数 1

分类专栏：后端学习文章标签：多线程 java

本文链接：https://blog.csdn.net/weixin_44293582/article/details/109895673

版权

后端学习专栏收录该内容

24 篇文章 0 订阅

订阅专栏

第十四章多线程

之前学习的程序在没有跳转语句的前提下都是由上到下依次执行，那现在想要设计一个程序，边打游戏边听歌，该怎么设计？

要解决上述问题，咱们得使用多进程或多线程来解决。

14.1并发与并行

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oO8a6CS4-1605936076761)(JAVA基础.assets/image-20201117111134016.png)]

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
   
而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去执行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

14.2进程与线程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存控件，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

总结：一个程序至少有一个进程，一个进程可以包含多个线程

线程调度
- 分时调度
  所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
- 抢占式调度
  优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。
  - 设置线程的优先级
  - 抢占式调度详解
    大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：我现在一边打开微信、QQ、mk编辑器、wps、chrome等软件。此时这些程序是在同时运行，“感觉这些软件好像在同一时刻运行着”。
    
    实际上，CPU（中央处理器）使用抢占式调度模式在多个线程间进行着告诉的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而CPU在多个线程间切换速度相对我们的感觉要快的多，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序的运行效率，让CPU的使用率更高。

14.3创建线程类（使用Thread）

创建多线程程序的第一种方式：创建Thread类的子类
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

实现步骤：

创建一个Thread类的子类
在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
创建Thread类的子类对象
调用Thread类中的start方法，开启新的线程，执行run方法

void start（）使该线程开始执行；Java虚拟机调用该线程的run方法。
结果是两个线程并发地运行；当前线程已经结束执行后，不能再重新启动。

Java程序属于抢占式调度，哪个线程的优先级高，哪个线程就先执行；同一个优先级，随机选择一个执行。

14.4多线程原理

定义一个多线程代码，感受一下多线程原理：
自定义线程类：

public class MyThread extends Thread{
	/*
	* 利用继承中的特点
    * 将线程名称传递 进行设置
    */
    public MyThread(String name){
    	super(name);
    }
    /*
    * 重写run方法
    * 定义线程要执行的代码
    */
    public void run() {
    	for(int i = 0;i < 20;i++) {
        	//getName()方法 来自父亲
			System.out.println(getName() + i);
        }
    }
}

测试类：

public class Demo {
	public static void main(String[] args) {
    	System.out.println("这里是main线程");
        MyThread mt = new MyThread("小强");
        my.start();// 开启了一个新的线程
        for (int i = 0; i < 20;i++) {
        	System.out.printl("旺财：" + i);
        }
    }
}

流程图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9dqpaSBu-1605936076764)(JAVA基础.assets/image-20201117153152739.png)]

总结上述：
	程序启动运行main的时候，JVM启动一个进程，主线程main在main（）调用的时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

	通过上图我们可以很清晰的看到多线程的执行流程，那么为什么可以完成并发执行呢？
	多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

底层调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jku2FFq6-1605936076766)(JAVA基础.assets/image-20201117154131787.png)]

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

14.5Thread类

java.lang.Thread类，API中该类中定义了有关线程的一些方法，具体如下：
构造方法

public Thread():分配一个新的线程对象。
public Thread(String name):分配一个指定名字的新的线程对象。
public Thread(Runnable target):分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法

public String getName():获取当前线程名称。
public void start():导致此线程开始执行；Java虚拟机调用此线程的run方法。
public void run():此线程要执行的任务在此处定义代码。
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currenThread():返回对当前正在执行的线程对象的引用。

创建线程的方式有两种
一种是继承Thread类方式
一种是实现Runnable接口方式

14.6创建线程方式二（Runnable接口）

采用java.lang.Runnable也是一种非常常见的创建线程的方法的一种，我们只需要重写run方法即可。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象start（）方法来启动线程。

代码如下：

public class MyRunnable implements Runnable{ 		@Override 
    public void run()
    { for (int i = 0; i < 20; i++) { 			 
  System.out.println(Thread.currentThread().getName()+" "+i); 
       } 
    } 
}

public class Demo { 
    public static void main(String[] args) {
        //创建自定义类对象 线程任务对象 
        MyRunnable mr = new MyRunnable(); 
        //创建线程对象 
        Thread t = new Thread(mr, "小强"); 				t.start(); 
        for (int i = 0; i < 20; i++) { 					System.out.println("旺财 " + i); 
     	 } 
    } 
}

通过实现Runnable接口，使得该类有了多线程类的特征。
run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。
Thread类实际上也是实现了Runnable接口的类。 
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。 
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。
因此,不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程 编程的基础。

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

Thread和Runnnable的区别

如果一个类继承Thread，则不适合资源共享。
如果一个类实现了Runnable接口的话，则很容易的实现资源共享

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runnable或Callbable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程。

14.7匿名内部类实现线程的创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

public class NoNameInnerClassThread {
	public static void main(String[] args) {
    	Runnable r = new　Runnable() {
        	public void run() {
            	for (int i = 0; i < 20; i++){
                	System.out.println("张宇:"+i);
                }
            }
        };
        new Thread(r).start();
        for (int i = 0; i < 20; i++){
                	System.out.println("费玉清:"+i);
                }
    }
}

第十五章线程安全

15.1线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

我们通过一个案例，演示线程的安全问题：电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个 (本场电影只能卖100张票)。我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票) 需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

模拟票：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-geqTCcSI-1605936076768)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121095516156.png)]

测试类：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SnrE2l23-1605936076770)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121095530538.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UGpWBav9-1605936076771)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121095540059.png)]

15.2线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
    要解决上述多线程并发访问一个资源的安全性问题，也就是解决重复票与不存在票的问题，Java中提供了同步机制（synchronized）来解决。
    解决方案：
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的问题。

有三种方式完成同步操作：

同步代码块
同步方法
锁机制

15.3同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式：

synchronized(同步锁) {
	需要同步操作的代码
}

同步锁：
对象的同步锁只是一个概念，可以想想在对象上标记了一个锁。

锁对象可以是任意类型。
多个线程对象，要使用同一把锁。

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SaOyKk1J-1605936076772)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121100329321.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4rnnutuu-1605936076772)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121100334988.png)]

15.4同步方法

**同步方法：**使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式：

public synchronized void method() {
	可能会产生线程安全问题的代码
}

同步锁是谁？

对于非static方法，同步锁就是this

对于static方法，我们使用当前方法所在类的字节码对象（类名.class)。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6UDuAYOM-1605936076773)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121100532335.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQaXfmT9-1605936076773)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121100536659.png)]

15.5Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock():加同步锁
public void unlock():释放同步锁

使用如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DOYcB0iy-1605936076774)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121100801873.png)]

第十六章线程状态

16.1线程状态概述

当线程被创建并启动以后，它既不是已启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在APIjava.lang.Thread.State这个枚举中给出了六种线程状态：
这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vCPDtkHC-1605936076775)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121100951709.png)]

16.2Timed Waiting（计时等待）

Timed Wating 在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一装填。单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了。

在我们写卖票的案例中，为了减少线程执行太快，线程不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。

当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，这就是所谓的Timed Watiting（计时等待），那么我们通过一个案例加深对该状态的一个理解。

实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串

代码：

package threadSecure;

/**
 * @author Administrator
 * @date 2020/11/2110:27
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 10 == 0) {
                System.out.println("------" + i);
            }
            System.out.println(i);
            try {
                Thread.sleep(1000);
                System.out.println("线程睡眠1秒！\n");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new MyThread().start();
    }
}

我们需要记住以下三点：

进入TIMED_WATING状态的一种常见情形是调用的sleep方法，单独的线程也可以调用，不一定非要有先做关系。
为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run（）之内。这样才能保证该线程执行过程中会睡眠。
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。

小提示：sleep（）中指定的时间是线程不会运行的最短时间。因此，sleep（）方法不能保证该线程到期后就开始立刻执行

Timed Wating 线程状态图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6jgEWSmU-1605936076775)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121103447305.png)]

16.3Blocked（锁阻塞）

Blocked状态：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

比如：线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入到Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。

Blocked线程状态图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U60tafUR-1605936076776)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121103757305.png)]

16.4Waiting（无限等待）

Waiting状态：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

代码案例：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7XUBQRTe-1605936076776)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121104039048.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ihcTrcRK-1605936076777)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121104050060.png)]

通过上述案例我们会发现，一个调用了某个对象的Object.wait()方法的线程会等待另一个线程调用此对象的Object.notify()方法或Objeck.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多时一起合作以完成某些任务。

当多个线程协作时，比如A、B线程，如果A线程在Runnable（可运行）状态中调用了wait（）方法，那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify（）方法，那么就会将无限等待的A线程唤醒。注意时唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取到锁对象，那么久进入到Blocked（锁阻塞状态）。

Waiting线程状态图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OcRcCOHH-1605936076777)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121104551034.png)]

16.5补充

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lfbXviCP-1605936076778)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121104709246.png)]

总结：notify（）或者notifyAll可以唤醒睡眠线程，无论该线程是处于计时等待状态还是无限等待状态。

第十七章等待唤醒机制

17.1线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务（却不相同。

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xI8deTci-1605936076778)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121105333288.png)]

为什么要处理线程间通信：

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

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

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

17.2等待唤醒机制

什么使等待唤醒机制

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

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

wait/notify就是线程间的一种协作机制。

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
	1.wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程状态时WAITING。它还要等着别的线程进行一个特别的动作，也就是“通知（notify）”在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）中
	2.notify：则选取所通知对象的wait set中的一个线程释放；
	3.notifyAll：释放所有通知对象的wait set上的全部线程。

注意：

哪怕只通知了一个等待的线程，被通知线程也不会立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其他线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。

总结：

如果能获取锁，线程就从WAITING状态变成RUNNABLE状态；
否则，从wait set出来，又进入entry set，线程就从WAITING状态又变成BLOCKED状态

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

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

17.3生产者与消费者

等待唤醒机制其实就是经典的“生产者与消费者”的问题

就拿生产包子消费包子来说等待唤醒机制如果有效利用资源：

首先：创建消费者吃包子的类以及生产者包子铺的类，这两个类中的run方法中调用了共享资源部分的代码需要使用同步方法来保证线程安全问题。当消费者过来，包子铺没有包子的时候，消费者进入睡眠状态，包子铺做包子，包子做好之后，包子铺唤醒消费者并进入睡眠状态，此时有包子了，消费者可以吃包子。如此反复即为生产者与消费者的代码实现。

代码实例：

包子资源类：

package threadSecure;

/**
 * @author Administrator
 * @date 2020/11/2111:20
 */
public class BaoZi {
    private String name;
    private boolean flag;

    public BaoZi(String name, boolean flag) {
        this.name = name;
        this.flag = flag;
    }

    @Override
    public String toString() {
        return "BaoZi{" +
                "name='" + name + '\'' +
                ", flag=" + flag +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

吃货线程类：

package threadSecure;


/**
 * @author Administrator
 * @date 2020/11/2111:22
 */
public class Consummer implements Runnable{
    private BaoZi baoZi;


    public Consummer(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baoZi){
                // 如果包子资源存在，那么吃包子
                if (baoZi.isFlag()) {
                    System.out.println("消费者：我要吃包子了");
                    baoZi.notify();
                    baoZi.setFlag(false);
                }
                // 如果没有包子，那么进入睡眠
                try {
                    baoZi.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

包子铺线程类：

package threadSecure;

/**
 * @author Administrator
 * @date 2020/11/2111:39
 */
public class Producer implements Runnable{
    private BaoZi baoZi;

    public Producer(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    @Override
    public void run() {

        while (true) {
            synchronized(baoZi) {
                // 如果包子资源存在，那么进入睡眠状态
                if (baoZi.isFlag()) {
                    try {
                        baoZi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 否则包子资源不存在
                baoZi.setFlag(true);
                System.out.println("生产者包子做好了！");
                baoZi.notify();
            }
        }
    }
}

第十八章线程池

18.1线程池思想概述

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程需要时间。

那么有没有一种办法使得线程可以服用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？

在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池。

18.2线程池的概念

**线程池：**其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

线程池的工作原理：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S2yb3Wvb-1605936076779)(JAVA%E5%9F%BA%E7%A1%80.assets/image-20201121122956212.png)]

合理利用线程池能够带来的三个好处：

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

18.3线程池的使用

Java里面线程池的顶级接口时java.util.concurrent.Executor，但时严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工厂类来创建线程池对象。

Excutors类中有个创建线程池的方法如下：

public static ExecutorService newFixedThreadPool(int nThreads):返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

使用线程池中线程对象的步骤：

创建线程池对象
创建Runnable接口子类对象。（task）
提交Runnable接口子类对象。（task task）
关闭线程池（一般不做）

Runnable实现类：

package threadPools;

/**
 * @author Administrator
 * @date 2020/11/2113:10
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "教练来了");
        System.out.println(Thread.currentThread().getName() + "教练教完我回到游泳池了");
    }
}

线程池测试类：

package threadPools;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Administrator
 * @date 2020/11/2113:12
 */
public class PoolsTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);

        MyRunnable r = new MyRunnable();
        service.submit(r);
        service.submit(r);
        service.submit(r);
        service.submit(r);

        service.shutdown();
    }
}

东皇太乙

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java并发编程

第十四章多线程之前学习的程序在没有跳转语句的前提下都是由上到下依次执行，那现在想要设计一个程序，边打游戏边听歌，该怎么设计？要解决上述问题，咱们得使用多进程或多线程来解决。14.1并发与并行并发：指两个或多个事件在同一时间段内发生。并行：指两个或多个事件在同一时刻发生（同时发生）[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oO8a6CS4-1605936076761)(JAVA基础.assets/image-20201117111134016.png)]
复制链接

扫一扫