Java程序员必经的实践之路：Java中高级核心知识全面解析(11)
ThreadPoolTaskExecutor定义一些策略:
ThreadPoolExecutor.AbortPolicy：抛出RejectedExecutionException来拒绝新任务的处理。ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略。ThreadPoolExecutor.DiscardPolicy： 不处理新任务，直接丢弃掉。ThreadPoolExecutor.DiscardOldestPolicy： 此策略将丢弃最早的未处理的任务请求。
举个例子：
Spring 通过
ThreadPoolTaskExecutor或者我们直接通过ThreadPoolExecutor的构造函数创建线程池的时候，当我们不指定RejectedExecutionHandler饱和策略的话来配置线程池的时候默认使用的是ThreadPoolExecutor.AbortPolicy。在默认情况下，
ThreadPoolExecutor将抛出RejectedExecutionException来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用
ThreadPoolExecutor.CallerRunsPolicy。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看ThreadPoolExecutor的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。）
2.推荐使用 ThreadPoolExecutor 构造函数创建线程池
为什么呢？
使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
强制线程池不允许使用 Executors 去创建，而是通过ThreadPoolExecutor构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险
Executors 返回线程池对象的弊端如下：
FixedThreadPool和SingleThreadExecutor： 允许请求的队列长度为Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。- CachedThreadPool和ScheduledThreadPool： 允许创建的线程数量为Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。
方式一：通过ThreadPoolExecutor构造函数实现（推荐）
方式二：通过 Executor 框架的工具类 Executors 来实现
我们可以创建三种类型的 ThreadPoolExecutor：
- FixedThreadPool
- SingleThreadExecutor
- CachedThreadPool
对应 Executors 工具类中的方法如图所示：
四、 (重要)ThreadPoolExecutor 使用示例
我们上面讲解了Executor框架以及ThreadPoolExecutor类，下面让我们实战一下，来通过写一个ThreadPoolExecutor的小Demo来回顾上面的内容。
1.示例代码:Runnable+ ThreadPoolExecutor
首先创建一个Runnable接口的实现类（当然也可以是Callable接口，我们上面也说了两者的区别。）
MyRunnable.java
import java.util.Date;/**
* 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
* @author shuang.kou
*/public class MyRunnable implements Runnable {private String command; public MyRunnable(String s) { this.command = s;
}
@Override public void run() { System.out.println(Thread.currentThread().getName() + " Start. Time = "
+ new Date()); processCommand(); System.out.println(Thread.currentThread().getName() + " End. Time = "
+ new Date());
}private void processCommand() { try {Thread.sleep(5000);} catch (InterruptedException e) { e.printStackTrace(); }
}@Override public String toString() { return this.command; }
}
编写测试程序，我们这里以阿里巴巴推荐的使用ThreadPoolExecutor构造函数自定义参数的方式来创建线程池。
ThreadPoolExecutorDemo.java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class ThreadPoolExecutorDemo {private static final int CORE_POOL_SIZE = 5;private static final int MAX_POOL_SIZE = 10; private static final int QUEUE_CAPACITY = 100; private static final Long KEEP_ALIVE_TIME = 1L; public static void main(String[] args) {//使用阿里巴巴推荐的创建线程池的方式 //通过ThreadPoolExecutor构造函数自定义参数创建ThreadPoolExecutor executor = new ThreadPoolExecutor( CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue<>(QUEUE_CAPACITY), new ThreadPoolExecutor.CallerRunsPolicy());for (int i = 0; i < 10; i++) { //创建WorkerThread对象（WorkerThread类实现了Runnable 接口） Runnable worker = new MyRunnable("" + i); //执行Runnable executor.execute(worker);}//终止线程池 executor.shutdown();while (!executor.isTerminated()) { }System.out.println("Finished all threads"); }
}
可以看到我们上面的代码指定了：
1.corePoolSize: 核心线程数为 5。
2.maximumPoolSize：最大线程数 10
3.keepAliveTime: 等待时间为 1L。
4.unit: 等待时间的单位为TimeUnit.SECONDS。
5.workQueue：任务队列为ArrayBlockingQueue，并且容量为 100;
6.handler:饱和策略为CallerRunsPolicy。
Output：
pool-1-thread-3 Start. Time = Sun Apr 12 11:14:37 CST 2020
pool-1-thread-5 Start. Time = Sun Apr 12 11:14:37 CST 2020
pool-1-thread-2 Start. Time = Sun Apr 12 11:14:37 CST 2020
pool-1-thread-1 Start. Time = Sun Apr 12 11:14:37 CST 2020
pool-1-thread-4 Start. Time = Sun Apr 12 11:14:37 CST 2020
pool-1-thread-3 End. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-4 End. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-1 End. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-5 End. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-1 Start. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-2 End. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-5 Start. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-4 Start. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-3 Start. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-2 Start. Time = Sun Apr 12 11:14:42 CST 2020
pool-1-thread-1 End. Time = Sun Apr 12 11:14:47 CST 2020
pool-1-thread-4 End. Time = Sun Apr 12 11:14:47 CST 2020
pool-1-thread-5 End. Time = Sun Apr 12 11:14:47 CST 2020
pool-1-thread-3 End. Time = Sun Apr 12 11:14:47 CST 2020
pool-1-thread-2 End. Time = Sun Apr 12 11:14:47 CST 2020
2.线程池原理分析
承接上一节，我们通过代码输出结果可以看出：线程首先会先执行 5 个任务，然后这些任务有任务被执行完的话，就会去拿新的任务执行。 大家可以先通过上面讲解的内容，分析一下到底是咋回事？（自己独立思考一会）
现在，我们就分析上面的输出内容来简单分析一下线程池原理。
**为了搞懂线程池的原理，我们需要首先分析一下execute方法。**在上一节中的Demo中我们使用executor.execute(worker)来提交一个任务到线程池中去，这个方法非常重要，下面我们来看看它的源码：
// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));private static int workerCountOf(int c) { return c & CAPACITY;
}
//任务队列
private final BlockingQueue<Runnable> workQueue;public void execute(Runnable command) {// 如果任务为null，则抛出异常。 if (command == null) throw new NullPointerException(); // ctl 中保存的线程池当前的一些状态信息 int c = ctl.get();// 下面会涉及到 3 步 操作 // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添 加到该线程中；然后，启动该线程从而执行任务。if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get();
}// 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里 // 通过 isRunning 方法判断线程池状态，线程池处于RUNNING状态才会被并且队列可以加入任务，该任务才会被加入进去if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get();// 再次获取线程池状态，如果线程池状态不是RUNNING状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。if (!isRunning(recheck) && remove(command)) reject(command);// 如果当前线程池为空就新创建一个线程并执行。else if (workerCountOf(recheck) == 0) addWorker(null, false);
}//3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。 //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。else if (!addWorker(command, false)) reject(command);
}
通过下图可以更好的对上面这 3 步做一个展示
addWorker这个方法主要用来创建新的工作线程，如果返回true说明创建和启动工作线程成功，否则的话返回的就是false。
// 全局锁，并发操作必备
private final ReentrantLock mainLock = new ReentrantLock();
// 跟踪线程池的最大大小，只有在持有全局锁mainLock的前提下才能访问此集合
private int largestPoolSize;
// 工作线程集合，存放线程池中所有的（活跃的）工作线程，只有在持有全局锁mainLock的前提下才 能访问此集合
private final HashSet<Worker> workers = new HashSet<>();
//获取线程池状态
private static int runStateOf(int c) { return c & ~CAPACITY;
}
//判断线程池的状态是否为
Running private static boolean isRunning(int c) { return c < SHUTDOWN;
}/**
* 添加新的工作线程到线程池
* @param firstTask 要执行
* @param core参数为true的话表示使用线程池的基本大小，为false使用线程池最大大小
* @return 添加成功就返回true否则返回false
*/
private boolean addWorker(Runnable firstTask, boolean core) {retry: for (;;) { //这两句用来获取线程池的状态 int c = ctl.get(); int rs = runStateOf(c);// Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false;for (;;) { //获取线程池中线程的数量 int wc = workerCountOf(c);// core参数为true的话表明队列也满了，线程池大小变为 maximumPoolSize if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; //原子操作将workcount的数量加1 if (compareAndIncrementWorkerCount(c)) break retry; // 如果线程的状态改变了就再次执行上述操作 c = ctl.get(); if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop }
}
// 标记工作线程是否启动成功
boolean workerStarted = false;
// 标记工作线程是否创建成功
boolean workerAdded = false;
Worker w = null;try {w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { // 加锁 final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {//获取线程池状态 int rs = runStateOf(ctl.get()); //rs < SHUTDOWN 如果线程池状态依然为RUNNING,并且线程的状态是存活的话，就会将工作线程添加到工作线程集合中 //(rs=SHUTDOWN && firstTask == null)如果线程池状态小于STOP，也就是 RUNNING或者SHUTDOWN状态下，同时传入的任务实例firstTask为null，则需要添加到工作线程集合和启 动新的Worker // firstTask == null证明只新建线程而不执行任务if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); workers.add(w);//更新当前工作线程的最大容量 int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; // 工作线程是否启动成功 workerAdded = true; } } finally { // 释放锁 mainLock.unlock(); } 如果成功添加工作线程，则调用Worker内部的线程实例t的Thread#start()方 法启动真实的线程实例if (workerAdded) { t.start(); /// 标记线程启动成功 workerStarted = true;}}
} finally { // 线程启动失败，需要从工作线程中移除对应的Worker if (! workerStarted) addWorkerFailed(w); }
return workerStarted;
}
现在，让我们在回到上一节我们写的Demo， 现在应该是不是很容易就可以搞懂它的原理了呢？
没搞懂的话，也没关系，可以看看我的分析：
我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的5个任务中如果有任务被执行完了，线程池就会去拿新的任务执行。
3.几个常见的对比
1)Runnable vs Callable
Runnable自Java 1.0以来一直存在，但Callable仅在 Java1.5中引入,目的就是为了来处理Runnable不支持的用例。 Runnable接口不会返回结果或抛出检查异常，但是Callable接口可以。所以，如果任务不需要返回结果或抛出异常推荐使用Runnable接口，这样代码看起来会更加简洁。
工具类Executors可以实现Runnable对象和Callable对象之间的相互转换。（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule） ）。
Runnable.java
@FunctionalInterface
public interface Runnable { /*** 被线程执行，没有返回值也无法抛出异常 */public abstract void run();
}
Callable.java
@FunctionalInterface
public interface Callable<V> { /*** 计算结果，或在无法这样做时抛出异常。* @return 计算得出的结果 * @throws 如果无法计算结果，则抛出异常 */ V call() throws Exception;
}
2) execute() vs submit()
1.execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
2.submit()方法用于提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个Future对象可以判断任务是否执行成功，并且可以通过Future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
我们以AbstractExecutorService接口中的一个 submit 方法为例子来看看源代码：
public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); return ftask;
}
上面方法调用的newTaskFor方法返回了一个FutureTask对象。
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { return new FutureTask<T>(runnable, value);
}
我们再来看看execute()方法：
public void execute(Runnable command) { ...
}
3)shutdown() VS shutdownNow()
shutdown（）:关闭线程池，线程池的状态变为SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。shutdownNow（）:关闭线程池，线程的状态变为STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的List。
4)isTerminated() VS isShutdown()
isShutDown当调用shutdown()方法后返回为 true。isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为 true
4.加餐: Callable + ThreadPoolExecutor 示例代码
MyCallable.java
import java.util.concurrent.Callable; public class MyCallable implements Callable<String> {@Override public String call() throws Exception { Thread.sleep(1000); //返回执行当前 Callable 的线程名字 return Thread.currentThread().getName(); }
}
CallableDemo.java
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class CallableDemo {private static final int CORE_POOL_SIZE = 5; private static final int MAX_POOL_SIZE = 10; private static final int QUEUE_CAPACITY = 100; private static final Long KEEP_ALIVE_TIME = 1L;public static void main(String[] args) {//使用阿里巴巴推荐的创建线程池的方式 //通过ThreadPoolExecutor构造函数自定义参数创建ThreadPoolExecutor executor = new ThreadPoolExecutor( CORE_POOL_SIZE,MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue<>(QUEUE_CAPACITY), new ThreadPoolExecutor.CallerRunsPolicy());List<Future<String>> futureList = new ArrayList<>(); Callable<String> callable = new MyCallable(); for (int i = 0; i < 10; i++) { //提交任务到线程池 Future<String> future = executor.submit(callable); //将返回值 future 添加到 list，我们可以通过 future 获得 执行 Callable 得到 的返回值 futureList.add(future); }for (Future<String> fut : futureList) { try {System.out.println(new Date() + "::" + fut.get());} catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }//关闭线程池 executor.shutdown(); }
}
Output:
Wed Nov 13 13:40:41 CST 2019::pool-1-thread-1
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-2
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-3
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-4
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-5
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-3
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-2
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-1
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-4
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-5
五、几种常见的线程池详解
1.FixedThreadPool
1)介绍
FixedThreadPool被称为可重用固定线程数的线程池。通过Executors类中的相关源代码来看一下相关实现：
/**
* 创建一个可重用固定数量线程的线程池
*/
public static ExecutorService newFixedThreadPool(int nThreads,
ThreadFactory threadFactory) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), threadFactory);
}
另外还有一个FixedThreadPool的实现方法，和上面的类似，所以这里不多做阐述：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
从上面源代码可以看出新创建的FixedThreadPool的corePoolSize和maximumPoolSize都被设置为nThreads，这个nThreads参数是我们使用的时候自己传递的。
2)执行任务过程介绍
FixedThreadPool的execute()方法运行示意图
上图说明：
- 如果当前运行的线程数小于 corePoolSize， 如果再来新任务的话，就创建新的线程来执行任务；
- 当前运行的线程数等于 corePoolSize 后， 如果再来新任务的话，会将任务加入
LinkedBlockingQueue； - 线程池中的线程执行完 手头的任务后，会在循环中反复从
LinkedBlockingQueue中获取任务来执行；
3)为什么不推荐使用 FixedThreadPool ？
FixedThreadPool使用无界队列LinkedBlockingQueue（队列的容量为 Intger.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响：
- 当线程池中的线程数达到
corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize； - 由于使用无界队列时
maximumPoolSize将是一个无效参数，因为不可能存在任务队列满的情况。所以，通过创建FixedThreadPool的源码可以看出创建的FixedThreadPool的corePoolSize和maximumPoolSize被设置为同一个值。 - 由于 1 和 2，使用无界队列时
keepAliveTime将是一个无效参数； - 运行中的
FixedThreadPool（未执行shutdown()或shutdownNow()）不会拒绝任务，在任务比较多的时候会导致 OOM（内存溢出）。
2.SingleThreadExecutor 详解
1)介绍
SingleThreadExecutor是只有一个线程的线程池。下面看SingleThreadExecutor的实现：
/**
*返回只有一个线程的线程池
*/
public static ExecutorService newSingleThreadExecutor(ThreadFactory
threadFactory) { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), threadFactory));
}
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, # **Kafka**进阶篇知识点**Kafka**高级篇知识点**44个Kafka知识点（基础+进阶+高级）解析如下**kingQueue<Runnable>(), threadFactory));
}
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, # **Kafka**进阶篇知识点[外链图片转存中...(img-Zb7gOH58-1628136033819)]**Kafka**高级篇知识点[外链图片转存中...(img-90fgmr8P-1628136033820)]**44个Kafka知识点（基础+进阶+高级）解析如下**[外链图片转存中...(img-YW9cqCER-1628136033822)]由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**，**[有需求的朋友可以戳这里免费下载](https://gitee.com/vip204888/java-p7)**
Java程序员必经的实践之路：Java中高级核心知识全面解析(11)相关推荐
- Java程序员必经的实践之路：docker离线导入镜像
1.1. 操作系统简介 我通过以下四点介绍什么是操作系统: 操作系统(Operating System,简称 OS)是管理计算机硬件与软件资源的程序,是计算机的基石. 操作系统本质上是一个运行在计算机 ...
- Java程序员必经的实践之路：微服务与SOA架构
而另一方面,微服务推崇执行的标准(例如HTTP)却是人们广泛了解并共同使用的.我们可以通过选择合适的语言或工具来构建某个组件微服务.SOA与微服务还有一个更大的区别:领域模型.在基于微服务的软件中,每 ...
- Java程序员必经的实践之路：java控制台在哪里打开
前言 作为一名编程人员,对MySQL一定不会陌生,尤其是互联网行业,对MySQL的使用是比较多的.对于求职者来说,MySQL又是面试中一定会问到的重点,很多人拥有大厂梦,却因为MySQL败下阵来.实际 ...
- java程序员的大数据之路（13）：Pig入门
Pig简介 Pig为大型数据集的处理提供了更高层次的抽象. Pig包括两部分: 用于描述数据流的语言,称为Pig Latin. 用于运行Pig Latin程序的执行环境.当前有两个环境:单JVM中的本 ...
- java程序员的大数据之路（3）：用maven构建Hadoop项目
背景 由于Hadoop项目多数是比较大的项目,因此我们选择使用构建工具来构建Hadoop项目,这里我们使用的是maven.当然也可以使用Gradle等比较流行的构建工具 构建过程 这里总结一下我使用I ...
- java 数学公式解析框架有哪些_java程序员该如何进阶？这份java中高级核心知识全面解析请收好...
<Java中高级核心知识全面解析>是整理收录GitHub50K+Star以上的高质量学习文档,前前后后花了近半个月的时间,终于整理而成.包含了Java基础.网络.Linux.数据结构与算法 ...
- 2019最新Java程序员面试指南——HR的套路+Java常见技术点
本文转载自:2019最新Java程序员面试指南--HR的套路+Java常见技术点 面试是件既简单又复杂的事情,也正是因为简单和复杂的两面性,所以Java程序员在面试的时候要多学些面试技巧,当然技术也不 ...
- java file取不到linux文件_Java中高级核心知识全面解析——Linux基本命令（切换、增删改查、压缩文件、权限命令）...
一.目录切换命令 cd usr: 切换到该目录下usr目录 cd ..(或cd../): 切换到上一层目录 cd /: 切换到系统根目录 cd ~: 切换到用户主目录 cd -: 切换到上一个操作所在 ...
- Java中高级核心知识全面解析——什么是Spring Cloud、需要掌握哪些知识点？（下）
目录 一.必不可少的 Hystrix 1.什么是 Hystrix之熔断和降级 2.什么是Hystrix之其他 二.微服务网关--Zuul 1.Zuul 的路由功能 1)简单配置 2)统一前缀 3)路由 ...
最新文章
- 本地清除电脑缓存后，mongodb数据库无法连接
- 中心化，去中心化？关乎互联网未来命运的重要选
- WPF/E 2007年2月CTP发布了
- JS展示预览PDF。
- 使用腾讯云提供的针对Nuget包管理器的缓存加速服务
- java hashmap实例,关于java中的HashMap的实例操作
- 软件测试b s环境如何配置,B/S架构测试环境搭建_DB2篇（Win32系统）
- ACE editor 在线代码编辑极其高亮
- 利用坐标变换证明惯性主轴方向是惯性矩的极值方向
- java运行多个linux命令_在shell的一行中运行多个命令
- 【图像处理】【去模糊】图像去模糊之初探--Single Image Motion Deblurring
- android下的jni
- echart 迁徙图
- 英语十大词性之三 - 形容词
- docker.socks vul
- 主、谓、宾、定、状、补
- 计算机在军事方面的应用
- 我爱高圆圆 键盘录入数据,模拟单项选择题
- Yii Framework 开发教程(32) Zii组件-GridView示例
- 禅意花园网页设计_CSS教程:15.1 “禅意花园”页面HTML结构分析