【java高性能编程基础】 - 线程池的应用及实现原理

最新推荐文章于 2024-01-31 16:07:13 发布
最新推荐文章于 2024-01-31 16:07:13 发布
阅读量225 收藏 1
点赞数 2
分类专栏： java高性能编程 文章标签： java 后端 线程池 高性能 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43598687/article/details/122435818
版权

文章目录

为什么要用线程池？

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

线程的数量是不是越多越好呢？

  1. 线程在java中是一个对象，更是操作系统的资源，线程的创建和销毁都需要时间。如果（创建时间+销毁时间）> （执行任务的时间），就很不合算。
  2. java对象占用堆内存，操作系统线程占用系统的内存，根据JVM规范：一个线程默认最大栈空间大小为1M，这个栈空间是需要从系统内存中分配的。所以线程过多，会消耗很多的内存。
  3. 在线程执行任务时，操作系统需要频繁的切换线程上下文，线程过多会影响性能。

线程池的退出，就是为了方便的控制线程数量。

线程池的原理

1、线程池管理器：
用于创建并管理线程池，包括创建线程池、销毁线程池、添加新任务。
2、工作线程：
线程池的中的线程，在没有任务时处于等待状态，每个线程都可以循环的执行任务。
3、任务接口：
每个任务必须实现的接口，以供工作线程调度任务的执行；
它主要规定了任务的入口、任务执行完后的收尾工作、任务的执行状态等。
4、任务队列：
用于存放没有处理的任务。提供一种缓冲机制。

线程池的接口定义和实现类API

java中操作线程池的api位于java.util.concurrent;包中。
Executor接口
最上层的接口，定义了执行任务的execute()方法。
在这里插入图片描述

ExecutorService接口
继承了Executor接口，扩展了Callable、Future、关闭方法。
在这里插入图片描述
ScheduledExecutorService接口
继承了ExecutorService接口，增加了定时任务相关的方法。
在这里插入图片描述ThreadPoolExecutor实现类
基础、标准的线程池实现。

ScheduledThreadPoolExecutor实现类
继承了ThreadPoolExecutor，实现了ScheduledExecutorService中定时任务相关的方法。
在这里插入图片描述后续将补充关于上述接口与实现类的源码分析。。。

Executors工具类

Executors类中提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

  • newFixedThreadPool(int nThreads)
    创建一个固定大小、任务队列容量无界的线程池。核心线程数=最大线程数。
  • newCachedThreadPool()
  • 创建的是一个大小无界的缓冲线程池。它的任务队列是一个同步队列。任务加入到池中，如果池中有空闲线程，则用空闲线程执行，如无则创建新线程执行。池中的线程空闲超过60秒，将被销毁释放。线程数随任务的多少变化。适用于执行耗时较小的异步任务。池的核心线程数=0，最大线程数= Integer.MAX_VALUE
  • newSingleThreadExecutor()
    只有一个线程来执行无界任务队列的单一线程池。该线程池确保任务按加入的顺序一个一个依次执行。当唯一的线程因任务异常中止时，将创建一个新的线程来继续执行后续的任务。与newFixedThreadPool(1)的区别在于，单一线程池的池大小在newSingleThreadExecutor方法中硬编码，不能再改变的。
  • newScheduledThreadPool(int corePoolSize)能定时执行任务的线程池。该池的核心线程数由参数指定，最大线程数= lnteger.MAX_VALUE。

剖析java中几种创建线程的几种方式

线程池应用示例

通过ThreadPoolExecutor实例创建。
1. 创建一个任务，交给线程池执行

/**
	 * 测试： 提交15个执行时间需要3秒的任务,看线程池的状况
	 * 
	 * @param threadPoolExecutor 传入不同的线程池，看不同的结果
	 * @throws Exception
	 */
public void testCommand(ThreadPoolExecutor threadPoolExecutor) throws Exception{
        for(int i=0;i<15;i++){
            int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try{
                        System.out.println("开始执行" + n);
                        Thread.sleep(3000L);
                        System.out.println("执行结束" + n);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            System.out.println("任务提交成功：" + i);
        }

        Thread.sleep(500L);
        System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为: " + threadPoolExecutor.getQueue().size());
        Thread.sleep(15000L);
        System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
    }

2. 创建线程池执行上面的任务

    /**
     * 核心线程个数：5个
     * 最大线程个数：10个
     * 超出核心线程个数的线程存活时间：5S
     * 队列大小：无界队列
     * @throws Exception
     */
    public void pool1() throws Exception {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>());
        testCommand(threadPoolExecutor);
    }

任务execute过程

  1. 是否达到核心线程数量?没达到，创建一个工作线程来执行任务。
  2. 工作队列是否已满?没满，则将新提交的任务存储在工作队列里。
  3. 是否达到线程池最大数量?没达到，则创建一个新的工作线程来执行任务。
  4. 最后，执行拒绝策略来处理这个任务。

在这里插入图片描述

各种线程池的使用

/** 线程池的使用 */
public class Demo9 {

	/**
	 * 测试： 提交15个执行时间需要3秒的任务,看线程池的状况
	 * 
	 * @param threadPoolExecutor 传入不同的线程池，看不同的结果
	 * @throws Exception
	 */
	public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
		// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
		for (int i = 0; i < 15; i++) {
			int n = i;
			threadPoolExecutor.submit(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("开始执行：" + n);
						Thread.sleep(3000L);
						System.err.println("执行结束:" + n);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
			System.out.println("任务提交成功 :" + i);
		}
		// 查看线程数量，查看队列等待数量
		Thread.sleep(500L);
		System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
		System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
		// 等待15秒，查看线程数量和队列数量（理论上，会被超出核心线程数量的线程自动销毁）
		Thread.sleep(15000L);
		System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
		System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
	}

	/**
	 * 1、线程池信息： 核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest1() throws Exception {
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>());

		testCommon(threadPoolExecutor);
		// 预计结果：线程池线程数量为：5,超出数量的任务，其他的进入队列中等待被执行
	}

	/**
	 * 2、 线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest2() throws Exception {
		// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
		// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.err.println("有任务被拒绝执行了");
					}
				});
		testCommon(threadPoolExecutor);
		// 预计结果：
		// 1、 5个任务直接分配线程开始执行
		// 2、 3个任务进入等待队列
		// 3、 队列不够用，临时加开5个线程来执行任务(5秒没活干就销毁)
		// 4、 队列和线程池都满了，剩下2个任务，没资源了，被拒绝执行。
		// 5、 任务执行，5秒后，如果无任务可执行，销毁临时创建的5个线程
	}

	/**
	 * 3、 线程池信息： 核心线程数量5，最大数量5，无界队列，超出核心线程数量的线程存活时间：5秒
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest3() throws Exception {
		// 和Executors.newFixedThreadPool(int nThreads)一样的
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue<Runnable>());
		testCommon(threadPoolExecutor);
		// 预计结：线程池线程数量为：5，超出数量的任务，其他的进入队列中等待被执行
	}

	/**
	 * 4、 线程池信息：
	 * 核心线程数量0，最大数量Integer.MAX_VALUE，SynchronousQueue队列，超出核心线程数量的线程存活时间：60秒
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest4() throws Exception {

		// SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。
		// 在使用SynchronousQueue作为工作队列的前提下，客户端代码向线程池提交任务时，
		// 而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务，
		// 那么相应的offer方法调用就会失败（即任务没有被存入工作队列）。
		// 此时，ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理（假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize）。

		// 和Executors.newCachedThreadPool()一样的
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>());
		testCommon(threadPoolExecutor);
		// 预计结果：
		// 1、 线程池线程数量为：15，超出数量的任务，其他的进入队列中等待被执行
		// 2、 所有任务执行结束，60秒后，如果无任务可执行，所有线程全部被销毁，池的大小恢复为0
		Thread.sleep(60000L);
		System.out.println("60秒后，再看线程池中的数量：" + threadPoolExecutor.getPoolSize());
	}

	/**
	 * 5、 定时执行线程池信息：3秒后执行，一次性任务，到点就执行 <br/>
	 * 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest5() throws Exception {
		// 和Executors.newScheduledThreadPool()一样的
		ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
		threadPoolExecutor.schedule(new Runnable() {
			@Override
			public void run() {
				System.out.println("任务被执行，现在时间：" + System.currentTimeMillis());
			}
		}, 3000, TimeUnit.MILLISECONDS);
		System.out.println(
				"定时任务，提交成功，时间是：" + System.currentTimeMillis() + ", 当前线程池中线程数量：" + threadPoolExecutor.getPoolSize());
		// 预计结果：任务在3秒后被执行一次
	}

	/**
	 * 6、 定时执行线程池信息：线程固定数量5 ，<br/>
	 * 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest6() throws Exception {
		ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
		// 周期性执行某一个任务，线程池提供了两种调度方式，这里单独演示一下。测试场景一样。
		// 测试场景：提交的任务需要3秒才能执行完毕。看两种不同调度方式的区别
		// 效果1： 提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，完毕后立刻执行)。
		// 也就是说这个代码中是，3秒钟执行一次（计算方式：每次执行三秒，间隔时间1秒，执行结束后马上开始下一次执行，无需等待）
		threadPoolExecutor.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(3000L);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("任务-1 被执行，现在时间：" + System.currentTimeMillis());
			}
		}, 2000, 1000, TimeUnit.MILLISECONDS);

		// 效果2：提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，等上一次执行完毕后再开始计时，等待1秒)。
		// 也就是说这个代码钟的效果看到的是：4秒执行一次。 （计算方式：每次执行3秒，间隔时间1秒，执行完以后再等待1秒，所以是 3+1）
		threadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(3000L);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("任务-2 被执行，现在时间：" + System.currentTimeMillis());
			}
		}, 2000, 1000, TimeUnit.MILLISECONDS);
	}

	/**
	 * 7、 终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest7() throws Exception {
		// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
		// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.err.println("有任务被拒绝执行了");
					}
				});
		// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
		for (int i = 0; i < 15; i++) {
			int n = i;
			threadPoolExecutor.submit(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("开始执行：" + n);
						Thread.sleep(3000L);
						System.err.println("执行结束:" + n);
					} catch (InterruptedException e) {
						System.out.println("异常：" + e.getMessage());
					}
				}
			});
			System.out.println("任务提交成功 :" + i);
		}
		// 1秒后终止线程池
		Thread.sleep(1000L);
		threadPoolExecutor.shutdown();
		// 再次提交提示失败
		threadPoolExecutor.submit(new Runnable() {
			@Override
			public void run() {
				System.out.println("追加一个任务");
			}
		});
		// 结果分析
		// 1、 10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行
		// 2、调用shutdown后，不接收新的任务，等待13任务执行结束
		// 3、 追加的任务在线程池关闭后，无法再提交，会被拒绝执行
	}

	/**
	 * 8、 立刻终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest8() throws Exception {
		// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
		// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.err.println("有任务被拒绝执行了");
					}
				});
		// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
		for (int i = 0; i < 15; i++) {
			int n = i;
			threadPoolExecutor.submit(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("开始执行：" + n);
						Thread.sleep(3000L);
						System.err.println("执行结束:" + n);
					} catch (InterruptedException e) {
						System.out.println("异常：" + e.getMessage());
					}
				}
			});
			System.out.println("任务提交成功 :" + i);
		}
		// 1秒后终止线程池
		Thread.sleep(1000L);
		List<Runnable> shutdownNow = threadPoolExecutor.shutdownNow();
		// 再次提交提示失败
		threadPoolExecutor.submit(new Runnable() {
			@Override
			public void run() {
				System.out.println("追加一个任务");
			}
		});
		System.out.println("未结束的任务有：" + shutdownNow.size());

		// 结果分析
		// 1、 10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行
		// 2、调用shutdownnow后，队列中的3个线程不再执行，10个线程被终止
		// 3、 追加的任务在线程池关闭后，无法再提交，会被拒绝执行
	}

	public static void main(String[] args) throws Exception {
		new Demo9().threadPoolExecutorTest1();
//		new Demo9().threadPoolExecutorTest2();
//		new Demo9().threadPoolExecutorTest3();
//		new Demo9().threadPoolExecutorTest4();
//		new Demo9().threadPoolExecutorTest5();
//		new Demo9().threadPoolExecutorTest6();
//		new Demo9().threadPoolExecutorTest7();
//		new Demo9().threadPoolExecutorTest8();
	}
}
1 + 1=王
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java并发编程基础.pdf
04-19
Java并发编程基础主要包括以下几个核心方面： 线程与线程状态：理解Java中线程的基本概念，包括线程的创建、启动、暂停、恢复和终止。熟悉线程的生命周期及其不同状态，如新建、就绪、运行、阻塞和死亡。 线程同步...
java并发编程综合讲解
08-09
通过深入学习，您将能够更好地理解并发编程的挑战，掌握构建高性能、高可伸缩性的并发应用所需的技能。 在资源内容中，我们将涵盖以下关键方面： 首先，我们将简要概述 JUC 库的重要性以及它在现代多核处理器环境中...
多线程与线程池技术详解
02-14
在当前的Java面试和后台开发中，多线程与线程池技术越来越重要。毫不夸张的说，如何你想进入任何一家好的网络公司并能够长足发展，多线程与线程池技术是必须要掌握的技能！
七、ExecutorService的API
qq_30118563的博客
11-15 979
七、ExecutorService的API 7.1 API overview 首先来概览一下，这个接口大概有哪些重要API： invokeAny() 与 invokeAll() 具有阻塞特性 invokeAny() 取得第一个完成任务的结果值，当第一个任务执行完成后，调用interrupt() 中断其他任务，所以可以结合if（Thread.intterruptted()）决定任务是否继续运...
Thread.sleep()总结
qq836869520的博客
01-31 527
在Java中，是Thread类提供的一个静态方法，用于让当前执行的线程休眠（暂停执行）一段时间。其中，millis参数表示线程休眠的时间，单位是毫秒。调用这个方法会让当前线程暂停执行，进入休眠状态，但不会释放它所持有的任何锁。是控制线程执行速度的重要工具之一。通过合理使用它，我们可以实现线程之间的协同工作，有效地管理程序的执行流程。在实际应用中，根据具体场景和需求，合理选择线程休眠的时间，以达到更好的程序性能和用户体验。希望本文能够帮助你更好地理解和使用方法。
1.1.5 线程池原理
「南小鸟」的博客
08-27 163
为什么要用线程池？ 线程是不是越多越好？ 1、线程在Java中是一个对象，更是操作系统的资源，线程的创建、销毁都需要时间。 如果创建时间+销毁时间>执行任务的时间 就很不划算。 2、Java对象占用堆内存，操作系统线程占用系统内存，根据JVM规范，一条线程默认最大栈大小为1M， 这个栈空间是需要从系统内存中分配的。线程过多会消耗很多的内存。 3、...
ExecutorService线程池
qq_27242695的博客
01-29 399
文章目录ExecutorService线程池1 ExecutorService API 介绍1.1 api1.1.1 awaitTermination 方法1.1.2 invokeAll 方法1.1.3 invokeAny方法1.1.4 shutdown 方法1.1.5 shutdownNow方法1.1.6 isShutdown方法1.1.7 submit方法1.1.8 isTerminated方法 ExecutorService线程池 1 ExecutorService API 介绍 1.1 api 1
实验探究-ExecutorServiceAPI----未完待续！！！！具体细节问题之后补充
一个搬砖工人
11-26 562
**try {}
linux网络编程框架（C++）基于Reactor事件机制，支持线程池，异步非阻塞，高并发，高性能.zip
03-17
对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】： 有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 鼓励下载和使用，并欢迎大家互相学习，共同...
Java并发编程（学习笔记）.xmind
06-19
Java并发编程 背景介绍 并发历史 必要性 进程 资源分配的最小单位 线程 CPU调度的最小单位 线程的优势 （1）如果设计正确，多线程程序可以通过提高处理器资源的利用率来提升系统吞吐率 ...
JAVA高质量并发详解,多线程并发深入讲解
最新发布
04-24
本书全面解析了Java并发编程的核心概念、原理和实践，帮助读者深入理解多线程并发编程的精髓，提升编程能力和系统性能。 书中首先介绍了并发编程的基础知识，包括线程的基本概念、线程的生命周期、线程安全等问题。...
java大作业设计报告-JAVA聊天室.doc
05-29
JAVA程序设计 多人聊天室 设计目的 Java 编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高 性能、多线程和静态的语言。本次课程设计旨在应用JAVA编程语言中的网络通信，多线 程，...
java并发编程从入门到精通
03-26
《Java并发编程从入门到精通》作者结合自己10多年Java并发编程经验，详细介绍了Java并发编程的基础概念、工作原理、编程技巧和注意事项，对Java高性能高并发编程有极大的参考价值。 《Java并发编程从入门到精通》...
Java 并发编程实战
05-21
1.3.3　性能问题 1.4　线程无处不在 第一部分　基础知识 第2章　线程安全性 2.1　什么是线程安全性 2.2　原子性 2.2.1　竞态条件 2.2.2　示例：延迟初始化中的竞态条件 2.2.3　复合操作 2.3　加锁机制 2.3.1　内置锁...
JAVA并发编程实践_中文版(1-16章全)_1/4
04-21
真正的Addison-Wesley 出品的Java Concurrency in Practice 中文版 目录回到顶部↑ 代码清单 序 第1章 介绍 1.1 并发的（非常）简短历史 1.2 线程的优点 1.3 线程的风险 1.4 线程无处不在 第1部分 基础 第2章 线程...
Java并发编程实践 PDF 高清版
06-25
随着多核处理器的普及，使用并发成为构建高性能应用程序的关键。Java 5以及6在开发并发程序取得了显著的进步，提高了Java虚拟机的性能，提高了并发类的可伸缩性，并加入了丰富的新并发构建块。在本书中，这些便利...
java8源码-SpringTree:互联网通用技术
06-04
函数式编程基础，优化美丽的高性能代码 函数式编程 Consumer 3:Redis 让业务更快，让锁，mq有多重选择 4:Guava Ratelimiter接口限速 Preconditions参数检测 本地缓存 CacheBuilder（相比于数组,List, 可固定大小，...
实战Java高并发程序设计（第2版）PPT模板.pptx
05-31
5并行模式与算法 5.1探讨单例模式 5.3生产者-消费者模式 5.5future模式 5.2不变模式 5.4高性能的生产者-消费者模式：无锁的实现 5.6并行流水线 01 02 03 04 05 06 实战Java高并发程序设计（第2版）PPT模板全文共25...
Java并发编程part2
04-16
中文完整版的Java并发编程实践PDF电子书 作者:Brian Gogetz Tim Peierls Joshua Bloch Joseph Bowbeer David Holmes Doug Lea 译者:韩锴 方秒 目录 第1章 介绍 1.1 并发的（非常）简短历史 1.2 线程的优点 1.3 ...
亿级流量java高并发与网络编程实战pdf下载
12-31
Java高并发与网络编程是当前互联网行业非常热门的技术方向之一。在处理亿级流量的情况下，这些技术更是必不可少的。Java作为一种高性能的编程语言，其在高并发和网络编程方面有着非常丰富的应用经验，因此学习这些知识对于提升自身的技术水平是非常有帮助的。 对于想要深入学习Java高并发与网络编程的人来说，《亿级流量Java高并发与网络编程实战》这本书是一本非常值得阅读的好书。这本书系统全面地介绍了Java高并发编程的基本原理、实战技巧和常见问题解决方案，同时也深入探讨了Java网络编程的相关内容，涵盖了网络通信、Socket编程、NIO与Netty等重要知识。 通过阅读这本书，读者可以了解到Java高并发编程中的线程池、锁机制、并发集合等核心知识，还可以学习到如何设计高性能的并发程序以及应对高并发场景下的常见问题。同时，本书也详细介绍了Java网络编程中的各种网络协议、通信模型，以及如何利用Java技术构建高性能的网络应用程序。 总的来说，《亿级流量Java高并发与网络编程实战》这本书通过丰富的案例和实战经验，为想要深入学习Java高并发与网络编程的读者提供了一本权威、全面的学习指南。阅读本书不仅可以帮助读者系统地理解Java高并发与网络编程的知识，还可以帮助他们提升解决实际问题的能力，为今后的技术实践打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

1 + 1=王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值