「javase章节」Javase教程

admin 2023-01-02 13:18:07 746

今天给各位分享javase章节的知识，其中也会对Javase教程进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、java的三个体系Java SE，Java EE，Java ME,我在网上都看到它的定义，但是我不理解啊！怎么理解？？
2、想要自学JAVA，应该如何入门？
3、零基础学java应该从哪里开始？
4、javase线程怎么存储到容器

java的三个体系Java SE，Java EE，Java ME,我在网上都看到它的定义，但是我不理解啊！怎么理解？？

可以这么说，JavaSE是你所谓的三大体系的基础，无论你走哪条路，都必须经过JavaSE这个阶段。这是因为，JavaSE实际上就是java基础，包括java的语法和关键字以及一些面向对象之类的基础性知识。在JavaSE入门级的书籍里，你都能看到详细的java基础章节，通常会有大篇幅讲解如下内容：

java的数据类型，java关键字，java控制语句，java面向对象（即关于类、接口这部分的学习，但都比较基础，只学习类和接口的定义和使用），java界面编程（awt或者swing）以及java I/O系统。

等你把java的语法和面向对象弄懂了，再学习点界面编程，基本就算你会JavaSE了。JavaSE是用来编写那些在桌面运行的软件的，就像MFC这一类的。但在微软称霸的年代里，java是不大可能在电脑上的桌面软件有大的成就的。

所以，你不用理什么是JavaSE，因为你学习了java，在不懂这三大体系是什么东西的时候，你就已经具备了进入JavaSE的基础了。

JavaEE是javaWeb编程的一个方向，主要写一些在服务器运行的代码，来支持一些网页的运行，并处理网页系统的后台。学习JavaEE是需要java基础的，这是因为JavaEE不是一种单一的技术，不想JavaSE那样，单纯的java就行。JavaEE做的是B/S结构的系统，也就是网页，用浏览器就能使用的系统。它的前台一般使用jsp（类似于html，php，asp之类的网页语言）来编写，后台则是大量的java代码，用来处理前台传送的数据，并向客户端发送数据。在后台的java代码中，除了一些类是JavaEE中用的比较多而其他两个用的少之外，几乎你在JavaSE中学到的东西都能在JavaEE中用到，因为说到底这些还都是java程序。

正如前面所说，JavaEE是一种多技术的集合，如果你要向着JavaEE方向前进而且希望能进这个大门，那么你就要做好学习更多知识的准备，以下是一些基本都该学的技术：

html，css，javascript（这三者都是网页编程的基础，你可以不精通，但至少你该知道这些，并能简单的运用），sql（现在几乎没有哪个网页不用到数据库），由sql引发开来，你还要学习mysql，oracle或者sqlserver至少一个主流的数据库的使用，还要学会JDBC来连接数据库和jsp。然后你才能来学习jsp，servlet，直到三大框架SSH或者其他什么框架。

当你对以上知识都略懂的时候，可能你就可以找份简单的java工程师的工作了。

关于JavaME，它是用来做移动设备上的程序开发的，比如一些机顶盒，手机游戏等等。早几年很是流行这些java编写的手机游戏。但是在当今，android的势头已经不可抵挡，JavaME也就随之堕落了。但到底android的也是java系列的，使用的还是java语言，所以会写JavaME也不是没有用，而且未来手机怎么发展谁也没法预料，说不定哪天JavaME又雄起了呢？而且现在JavaME的工作应该也是有的。JavaME与前两者的关系有那么一点远，这是因为手机等小型设备不必电脑，cpu和存储设备跟不上，在电脑上运行的java虚拟机也没办法直接在这些设备上用。有鉴于此，JavaME有自己的运行环境，但它还是使用的java，所以如果你要学习JavaME，有了java基础，只需要学习JavaME的编程思想就行了。需要注意的是，一些java系统类在JavaME中不能用了，因为JavaME的虚拟机没有电脑上的java虚拟机大，所以不是所有的东西JavaME的虚拟机都能使用。

我不懂C#，但我知道C#可以写网页程序，也可以写桌面软件，这两点java都能做到。但问题是，C#有个牛B的爹，windows的系统任它驰骋，但java不行，java一蹦，微软就得想点办法打压一下。事实上，C#就是这么生出来的，它就是来跟java对着干的，java干啥，它就想干点啥。

java三大体系中，除了JavaSE是java基本的类库，基本上JavaEE和JavaME都需要有额外的类库来支持，这是显而易见的，JavaSE只是基础，那些基本类库就足以干出点名堂，但另外两者要去做更复杂的事，如果不提供额外的类库，那它和其他编程语言就没啥区别了，别的语言也早就到这两个领域了。但好在JavaEE的额外类库不多，而JavaME的类库也只需要边用边查，所以也不是什么困难。

想要自学JAVA，应该如何入门？

全面系统的Java内容如下：

一、JavaSE基础篇

JavaSE就是一种标准版，是Java语言的基础部分，Java衍生出来的各种框架（如Spring系列）各种产品都是基于JavaSE标准，JavaSE是Java向上发展的基础，Java任何高级产品的底层基础都是JavaSE，通俗来讲这是所有孩子的”爹“。JavaSE如果学不好，理解不透彻，后面学习框架时就有如天书一般，所以JavaSE这部分的重要性是不言而喻的，希望各位初学者铭记。

主要包含内容：数据类型、基础语法、运算符、流程控制、数组、面向对象、常用类、异常处理、集合、IO流、多线程、反射、注解、解析、网络编程。

PS：JavaSE的内容非常庞大，任何一套JavaSE教程都不会把所有的方法讲一遍，只会挑平时工作中常用的内容来讲解，所以JavaSE里面的内容很多都是课后自己在API文档中慢慢宽咐了解的，你自己一定要学会主动学习，不能坐以待毙。

推荐学习书籍：Java核心技术

二、数据库篇

数据库是学习Java语言必学的一项内容，常见的数据库就是MySQL和Oracle这两种，作为初学者一般都是学习MySQL为主，一般情况下中小型企业都会选择MySQL数据库，比较大型的互联网公司会选择用Oracle，而学习Oracle相对于MySQL也要复杂一庆乎些，建议是主要学习MySQL数据库，Oracle作为了解即可。学习数据库较为简单，基本的操作就是增删改查。

三、Web开发

Web前端内容：HTML/CSS/JavaScript/（前端页面）

注意：Java后端开发可以不用过多关注HTML页面及CSS的处理，但是最起码要会用简单的HTML，JavaScript是必须要会的，因为Javaweb后端程序员毕竟要接触使用AJAX方式处理数据及显示。当然如果只关注服务器端实现而不考虑任何用户界面，则HTML、CSS、JavaScript都不用关注，但是完全脱离前端的开发现在虽然也不少，但是绝对不关心前端是不可能，尤其是JavaScript，但是前端却可以完全不关心服务器后台的任何实现。

推荐学习书籍：《JavaScript DOM编程艺术》（第二版）

四、高级框架

1、Springframework 核心IOC容器

2、Spring boot 在Spring基础上的更全面提升效率的Spring工具

3、ORM 框架当今流行使用较多的是Mybatis 和 MP(Mybatis插件)，Hibernate是可选性学习的

4、模板技术，比较成熟的Freemarker

5、Spring Cloud 微服务框架，Spring Cloud提供的全套的分布式系统解决方案。

五、工具

maven 是构建管理项目的工具，svn 和git是团队协作开发的项目源代码及相关文档资料管理工具，需要学习者初步掌握其应用。

像Tomcat，jetty ，resin，JBoss，GlassFish 等都是部署运行Java web应用的服务器。

以上就是初学者大概学习的内容，我是尽量站在初学者的角度来说的，没有写得特别复杂，怕初学者看不懂，没有实质性的帮助。所以我尽量用白话把话说的简单一些，给大家罗列出主要学习的Java知识点。

Java学到什么程度才能达到就业的水平？

不同的软件公司对研发人员的水平要求存在一定的差异，如果从大多数中小型企业来看能接受一个入职到本企业的IT技术人员通常需要具备以下能力。

1 理解掌握Java核心面向对象的设计思想和代码构建，能以面向对象方式设计编写业务功能；

2 熟练掌握至少两种数据库的开发，如Oracle，mySql，能熟练编写基本常用及高级的SQL语句；

3 必需掌握并熟练应用Springframework IOC容器，深入了解IOC及AOP概念并应用，使用MVC实现对web 请求做出处理；

4 熟练掌握Java处理数据库的ORM框架myBatis，JDBCTemplate，对Hibernate也应有所了解；

5 熟练应用Spring 增强工具集合Spring boot；

6 至少熟练使用Eclipse及IDEA集成开发工具构建应用程序；

7 能够基本掌握MVN GIT Maven 在项目中的使用；

8 前端开发必需掌握JavaScript和常用的JS框架

以上这些都是中小型软件企业的入职基本要求，如果你能够达到这个水平，找到一份Java工作应该是不难的。

推荐的学习方式：系统视频教程+书籍辅助+有人指导

视频教程：对于Java初学者来说，看视频学习也是最普通的方式，视频教程会把工作中常用的知识进行讲解，而且视频一般都是分章分节，每一个小节都只讲一个知识点，学习起来较为明确。但是视频教程尽量要完整，最好是一整套视频学习。

书籍辅助：书籍便于对理论知识的补充，以便更容易理解Java面向对象核心设计理念和代码实践功能。

PS：但是大部分人都没有耐心看不下去书，所以大部分人都是只看视频教程学习。如果自己能看的下去就看，看不下去就不看。

有人指导：大部分人都不可能全靠自己的能力把Java学的特别好，因为你不了解这个行业，也不知道怎么学，完全零基础自学Java想要找到工作，概率极低。所以建议如果真的想要做这行，尽量找人去带带你，有不懂的问题可以直接请教，少走弯路，提高效率。学习的质量决定以后工作的薪资以及起点，所以还是应该重视起来。

项目的重要性

很多Java初学者看完一些视频，学过一段时间就说自己“会了”。这里我需要给大家纠正一个问题，希望每个学习Java的知友都能明确学习编程的中心是什么。

其实在我看来，学习编程从来都不存在会不会这样的说法。学习编程不同于初中学的数学、物理、化学，记住一些公式，做同样一种类型的习题，就证明类似的题型你会做了。

编程只讲技术能力是什么水平、什么级别的，最能证明技术水平处在什么阶段的，就是在做项目的过程中，研发好的互联网产品，写代码的质量怎么样，排错能力怎么样，找BUG的能力怎么样，构思功能模块整体布局的能力怎么样等等。

做作为初学者想要达到入门的水平，就是自己具备了一些简单项目的编码能力，初学者最重要的一点就是培养自己的编程思维，每一个程序都是不一样的，你不可能都背下来，学编程也不是靠死记硬背的，你只有能去独立编码写一些东西的时候，才有就业的机会。

所以做项目的能力才能去衡量一个学习的水平处在什么阶段，而往往那些嘴上说“会了”的人，往往没写过多少代码，也一个项目做不了出来，这就是纸上谈兵，完全曲解了学习编程到底在学什么，也不知道应该往哪里去。

所以一个Java初学者在学习的整体过程中，必须要有两个能拿得出手，能写在简历上的项目作为找工作的资本，并且要对于这两个项目的前前后后相当了解，才可能最后面试成功，一个初学者在学习完Java所有内容后，如若还达不到可以做简单项目的水平，那么他整个学习过程还是白费，没有达到最终的学习目的，就是学习质量不过关。所以项目的重要性希望大家都明确，因为有太多Java初学者不知道最后学习的目的是什么，最后白白的浪费时间。

学习心态：

学习编程一定不是一个简单的事情，换句话说它还是挺困难的，毕竟能出去找到工作，就是少则五六千，多则上万的工种。这些知识都不是随随便便就是任何一个人都能学会的。关于这个学习心态，希望提示大家要把重心放到“学习”这件事上，因为我发现有很多Java初学者都是像“完成任务”一样去学习，所谓完成任务就是“我把这些视频看完就能找到工作吗”“我把这些都学完就能找到工作吗”学完并不等于“学会”，这是两种不同的概念。

你到底理没理解？

你到底能不能应用起来？

你到底用没用心？

你自己应该是最清楚的，我发现那些把学习当做完成任务一样去对待的，这样的人没有一个是有耐心的，自己在心里欺骗自己“把这些视频看完我就能找到工作”，到了最后自己就逐渐明白，完全是自欺欺人，最后放弃说自己不适合学这个。其实揭开这些人的面具真相就一个：他们没有耐心学习，也不喜欢学习，这是以前经历造成的，是多年的习惯导致的。

所以正确的学习心态一定是把关注点放到学习这件事本身，你要学会这些知识，这些内容，这些技术，这是需要一天一天逐渐积累起来的，并不是短时间就可以达到什么结果。

PS：如果你对于学习没什么耐心，没什么兴趣，我劝你不要来学习编程，学习编程绝对是一个耐心的活，也是需要不断学习和充电的行业。或者说已经到了信息时代，不爱学习的人，很难有耐心去学习知识的人，在信息时代是混不下去的，任何行业都是如此，不学习不进步不紧贴时代的人就一定会被淘汰。

最终自学Java能就业的人基本具备以下几点：

1、有超强的学习耐心及进取心

2、手不懒，代码写的足够多，熟能生巧

3、有一定的学习能力，善于自学善于自己解决问题

4、可以独立写一些简单的项目

零基础学java应该从哪里开始？

零基础学Java最开始要做的就是整理出一份Java学习路线，只有合理规划学习路线才能在最短的时间里有效的学习。下面来看一份Java的学习路线以供参考：

第一阶段、JavaSE 课时：20天

• Java基础语法• 面向对象基础• 常用API• 集合框架• 线程（池）• 代理反射• 网络编程

第二阶段、JavaWeb 课时：15天

• html•Css•javaScript•Jquery• JavaWeb• session（cookie）• filter• 上传和下载组件• JSP• Tomcat服务器• Druid连接池

第三阶段、企业级框架课时：25天

• Spring• SpringMVC• SpringBoot• MyBatis(MyBatis-plus)• Maven管理• Git•Tomcat集成•数据库分库分表

第四阶段、互联网前沿技术课时：25天

• Dubbo分布式框架• SpringCloud微服务• RocketMQ消息中间件• Redis缓存中间件• ES查询中间件• Vue前端框架•OSS对象存储中间件

javase线程怎么存储到容器

Java 并发重要知识点

java 线程池

ThreadPoolExecutor 类分析

ThreadPoolExecutor 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么）。

/**

* 用给定的初始参数创建一个新的ThreadPoolExecutor。

public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量

int maximumPoolSize,//线程池的最大线程数

long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间

TimeUnit unit,//时间单位

BlockingQueueRunnable workQueue,//任务队列，用来储存等待执行任务的队列

ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可

RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务

) {

if (corePoolSize 0 ||

maximumPoolSize = 0 ||

maximumPoolSize corePoolSize ||

keepAliveTime 0)

throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)

throw new NullPointerException();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.workQueue = workQueue;

this.keepAliveTime = unit.toNanos(keepAliveTime);

this.threadFactory = threadFactory;

this.handler = handler;

}

下面这些对创建非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。

ThreadPoolExecutor 3 个最重要的参数：

corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。

maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。

workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

ThreadPoolExecutor其他常见参数 :

keepAliveTime:当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；

unit : keepAliveTime 参数的时间单位。

threadFactory :executor 创建新线程的时候会用到。

handler :饱和策略。关于饱和策略下面单独介绍一下。

下面这张图可以加深你对线程池中各个参数的相互关系的理解（图片来源：《Java 性能调优实战》）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nzbqGRz9-1654600571133)()]

ThreadPoolExecutor 饱和策略定义:

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，ThreadPoolTaskExecutor 定义一些策略:

ThreadPoolExecutor.AbortPolicy ：抛出 RejectedExecutionException来拒绝新任务的处理。

ThreadPoolExecutor.CallerRunsPolicy ：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。

ThreadPoolExecutor.DiscardPolicy ：不处理新任务，直接丢弃掉。

ThreadPoolExecutor.DiscardOldestPolicy ：此策略将丢弃最早的未处理的任务请求。

举个例子：

Spring 通过 ThreadPoolTaskExecutor 或者我们直接通过 ThreadPoolExecutor 的构造函数创建线程池的时候，当我们不指定 RejectedExecutionHandler 饱和策略的话来配置线程池的时候默认使用的是 ThreadPoolExecutor.AbortPolicy。在默认情况下，ThreadPoolExecutor 将抛出 RejectedExecutionException 来拒绝新来的任务，这代表你将丢失对这个任务的处理。对于可伸缩的应用程序，建议使用 ThreadPoolExecutor.CallerRunsPolicy。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 ThreadPoolExecutor 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。）

推荐使用 ThreadPoolExecutor 构造函数创建线程池

在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

为什么呢？

使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

另外，《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下(后文会详细介绍到)：

FixedThreadPool 和 SingleThreadExecutor ：允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。

CachedThreadPool 和 ScheduledThreadPool ：允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。

方式一：通过ThreadPoolExecutor构造函数实现（推荐）通过构造方法实现

方式二：通过 Executor 框架的工具类 Executors 来实现我们可以创建三种类型的 ThreadPoolExecutor：

FixedThreadPool

SingleThreadExecutor

CachedThreadPool

对应 Executors 工具类中的方法如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YGd4ygZu-1654600571136)()]

正确配置线程池参数

说到如何给线程池配置参数，美团的骚操作至今让我难忘（后面会提到）！

我们先来看一下各种书籍和博客上一般推荐的配置线程池参数的方式，可以作为参考！

常规操作

很多人甚至可能都会觉得把线程池配置过大一点比较好！我觉得这明显是有问题的。就拿我们生活中非常常见的一例子来说：并不是人多就能把事情做好，增加了沟通交流成本。你本来一件事情只需要 3 个人做，你硬是拉来了 6 个人，会提升做事效率嘛？我想并不会。线程数量过多的影响也是和我们分配多少人做事情一样，对于多线程这个场景来说主要是增加了上下文切换成本。不清楚什么是上下文切换的话，可以看我下面的介绍。

上下文切换：

多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。

类比于实现世界中的人类通过合作做某件事情，我们可以肯定的一点是线程池大小设置过大或者过小都会有问题，合适的才是最好。

如果我们设置的线程池数量太小的话，如果同一时间有大量任务/请求需要处理，可能会导致大量的请求/任务在任务队列中排队等待执行，甚至会出现任务队列满了之后任务/请求无法处理的情况，或者大量任务堆积在任务队列导致 OOM。这样很明显是有问题的！ CPU 根本没有得到充分利用。

但是，如果我们设置线程数量太大，大量线程可能会同时在争取 CPU 资源，这样会导致大量的上下文切换，从而增加线程的执行时间，影响了整体执行效率。

有一个简单并且适用面比较广的公式：

CPU 密集型任务(N+1)：这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。

I/O 密集型任务(2N)：这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。

如何判断是 CPU 密集任务还是 IO 密集任务？

CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。但凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。

美团的骚操作

美团技术团队在《Java线程池实现原理及其在美团业务中的实践》open in new window这篇文章中介绍到对线程池参数实现可自定义配置的思路和方法。

美团技术团队的思路是主要对线程池的核心参数实现自定义可配置。这三个核心参数是：

corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。

maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。

workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

为什么是这三个参数？

我在这篇《新手也能看懂的线程池学习总结》open in new window 中就说过这三个参数是 ThreadPoolExecutor 最重要的参数，它们基本决定了线程池对于任务的处理策略。

如何支持参数动态配置？且看 ThreadPoolExecutor 提供的下面这些方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sm89qdJZ-1654600571137)()]

格外需要注意的是corePoolSize，程序运行期间的时候，我们调用 setCorePoolSize（）这个方法的话，线程池会首先判断当前工作线程数是否大于corePoolSize，如果大于的话就会回收工作线程。

另外，你也看到了上面并没有动态指定队列长度的方法，美团的方式是自定义了一个叫做 ResizableCapacityLinkedBlockIngQueue 的队列（主要就是把LinkedBlockingQueue的capacity 字段的final关键字修饰给去掉了，让它变为可变的）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cmNN5yAL-1654600571138)()]

还没看够？推荐 why神的[《如何设置线程池参数？美团给出了一个让面试官虎躯一震的回答。》open in new window](如何设置线程池参数？美团给出了一个让面试官虎躯一震的回答。 (qq.com))这篇文章，深度剖析，很不错哦！

Java 常见并发容器

JDK 提供的这些容器大部分在 java.util.concurrent 包中。

ConcurrentHashMap : 线程安全的 HashMap

CopyOnWriteArrayList : 线程安全的 List，在读多写少的场合性能非常好，远远好于 Vector。

ConcurrentLinkedQueue : 高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedList，这是一个非阻塞队列。

BlockingQueue : 这是一个接口，JDK 内部通过链表、数组等方式实现了这个接口。表示阻塞队列，非常适合用于作为数据共享的通道。

ConcurrentSkipListMap : 跳表的实现。这是一个 Map，使用跳表的数据结构进行快速查找。

ConcurrentHashMap

我们知道 HashMap 不是线程安全的，在并发场景下如果要保证一种可行的方式是使用 Collections.synchronizedMap() 方法来包装我们的 HashMap。但这是通过使用一个全局的锁来同步不同线程间的并发访问，因此会带来不可忽视的性能问题。

所以就有了 HashMap 的线程安全版本—— ConcurrentHashMap 的诞生。

在 ConcurrentHashMap 中，无论是读操作还是写操作都能保证很高的性能：在进行读操作时(几乎)不需要加锁，而在写操作时通过锁分段技术只对所操作的段加锁而不影响客户端对其它段的访问。

CopyOnWriteArrayList

CopyOnWriteArrayList 简介

public class CopyOnWriteArrayListE

extends Object

implements ListE, RandomAccess, Cloneable, Serializable

在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，因此对于每次读取都进行加锁其实是一种资源浪费。我们应该允许多个线程同时访问 List 的内部数据，毕竟读取操作是安全的。

这和我们之前在多线程章节讲过 ReentrantReadWriteLock 读写锁的思想非常类似，也就是读读共享、写写互斥、读写互斥、写读互斥。JDK 中提供了 CopyOnWriteArrayList 类比相比于在读写锁的思想又更进一步。为了将读取的性能发挥到极致，CopyOnWriteArrayList 读取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作。只有写入和写入之间需要进行同步等待。这样一来，读操作的性能就会大幅度提升。那它是怎么做的呢？

CopyOnWriteArrayList 是如何做到的？

CopyOnWriteArrayList 类的所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，我并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。

从 CopyOnWriteArrayList 的名字就能看出 CopyOnWriteArrayList 是满足 CopyOnWrite 的。所谓 CopyOnWrite 也就是说：在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了。

CopyOnWriteArrayList 读取和写入源码简单分析

CopyOnWriteArrayList 读取操作的实现

读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。

/** The array, accessed only via getArray/setArray. */

private transient volatile Object[] array;

public E get(int index) {

return get(getArray(), index);

}

@SuppressWarnings("unchecked")

private E get(Object[] a, int index) {

return (E) a[index];

}

final Object[] getArray() {

return array;

}

CopyOnWriteArrayList 写入操作的实现

CopyOnWriteArrayList 写入操作 add()方法在添加集合的时候加了锁，保证了同步，避免了多线程写的时候会 copy 出多个副本出来。

/**

* Appends the specified element to the end of this list.

* @param e element to be appended to this list

* @return {@code true} (as specified by {@link Collection#add})

public boolean add(E e) {

final ReentrantLock lock = this.lock;

lock.lock();//加锁

try {

Object[] elements = getArray();

int len = elements.length;

Object[] newElements = Arrays.copyOf(elements, len + 1);//拷贝新数组

newElements[len] = e;

setArray(newElements);

return true;

} finally {

lock.unlock();//释放锁

}

ConcurrentLinkedQueue

Java 提供的线程安全的 Queue 可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是 BlockingQueue，非阻塞队列的典型例子是 ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。阻塞队列可以通过加锁来实现，非阻塞队列可以通过 CAS 操作实现。

从名字可以看出，ConcurrentLinkedQueue这个队列使用链表作为其数据结构．ConcurrentLinkedQueue 应该算是在高并发环境中性能最好的队列了。它之所有能有很好的性能，是因为其内部复杂的实现。

ConcurrentLinkedQueue 内部代码我们就不分析了，大家知道 ConcurrentLinkedQueue 主要使用 CAS 非阻塞算法来实现线程安全就好了。

ConcurrentLinkedQueue 适合在对性能要求相对较高，同时对队列的读写存在多个线程同时进行的场景，即如果对队列加锁的成本较高则适合使用无锁的 ConcurrentLinkedQueue 来替代。

BlockingQueue

BlockingQueue 简介

上面我们己经提到了 ConcurrentLinkedQueue 作为高性能的非阻塞队列。下面我们要讲到的是阻塞队列——BlockingQueue。阻塞队列（BlockingQueue）被广泛使用在“生产者-消费者”问题中，其原因是 BlockingQueue 提供了可阻塞的插入和移除的方法。当队列容器已满，生产者线程会被阻塞，直到队列未满；当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。

BlockingQueue 是一个接口，继承自 Queue，所以其实现类也可以作为 Queue 的实现来使用，而 Queue 又继承自 Collection 接口。下面是 BlockingQueue 的相关实现类：

BlockingQueue 的实现类

下面主要介绍一下 3 个常见的 BlockingQueue 的实现类：ArrayBlockingQueue、LinkedBlockingQueue 、PriorityBlockingQueue 。

ArrayBlockingQueue

ArrayBlockingQueue 是 BlockingQueue 接口的有界队列实现类，底层采用数组来实现。

public class ArrayBlockingQueueE

extends AbstractQueueE

implements BlockingQueueE, Serializable{}

ArrayBlockingQueue 一旦创建，容量不能改变。其并发控制采用可重入锁 ReentrantLock ，不管是插入操作还是读取操作，都需要获取到锁才能进行操作。当队列容量满时，尝试将元素放入队列将导致操作阻塞;尝试从一个空队列中取一个元素也会同样阻塞。

ArrayBlockingQueue 默认情况下不能保证线程访问队列的公平性，所谓公平性是指严格按照线程等待的绝对时间顺序，即最先等待的线程能够最先访问到 ArrayBlockingQueue。而非公平性则是指访问 ArrayBlockingQueue 的顺序不是遵守严格的时间顺序，有可能存在，当 ArrayBlockingQueue 可以被访问时，长时间阻塞的线程依然无法访问到 ArrayBlockingQueue。如果保证公平性，通常会降低吞吐量。如果需要获得公平性的 ArrayBlockingQueue，可采用如下代码：

private static ArrayBlockingQueueInteger blockingQueue = new ArrayBlockingQueueInteger(10,true);

LinkedBlockingQueue

LinkedBlockingQueue 底层基于单向链表实现的阻塞队列，可以当做无界队列也可以当做有界队列来使用，同样满足 FIFO 的特性，与 ArrayBlockingQueue 相比起来具有更高的吞吐量，为了防止 LinkedBlockingQueue 容量迅速增，损耗大量内存。通常在创建 LinkedBlockingQueue 对象时，会指定其大小，如果未指定，容量等于 Integer.MAX_VALUE 。