首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >【并发那些事】线程有序化神器CompletionService

【并发那些事】线程有序化神器CompletionService

作者头像
Bug开发工程师
发布于 2020-03-02 09:29:24
发布于 2020-03-02 09:29:24
50400
代码可运行
举报
文章被收录于专栏:码农沉思录码农沉思录
运行总次数:0
代码可运行

点击上方“码农沉思录”,选择“设为星标”

优质文章,及时送达

前言

话说有一天,产品经理突然找到正在摸鱼的你。 产品:『我们要加一个聚合搜索功能,当用户在我们网站查询一件商品时,我们分别从 A、B、C 三个网站上查询这个信息,然后再把得到的结果返回给用户』 你:『哦,就是写个爬虫,从 3 个网站上抓取数据是吧?』 产品:『呸,爬虫是犯法的,这叫数据分析,怎么样,能实现吧?』 你:『可以』 产品:『好的,明天上线』 你:『。。。』

Code 1.0

你很快完成了开发,代码如下:

代码语言:javascript
代码运行次数:0
运行
复制
/*
 *
 *  * *
 *  *  * blog.coder4j.cn
 *  *  * Copyright (C) B0A6-B0B0 All Rights Reserved.
 *  *
 *
 */
package cn.coder4j.study.example.thread;

import cn.hutool.core.thread.ThreadUtil;
import com.google.common.collect.Lists;

import java.util.List;

/**
 * @author buhao
 * @version TestCompletionService.java, v 0.A B0B0-0B-A8 A9:0C buhao
 */
public class TestCompletionService {

    public static void main(String[] args) {
        // 查询信息
        String queryName = "java";
        // 调用查询接口
        long startTime = System.currentTimeMillis();
        List<String> result = queryInfoCode1(queryName);
        System.out.println("耗时: " + (System.currentTimeMillis() - startTime));
        System.out.println(result);
    }

    /**
     * 聚合查询信息 code 1
     *
     * @param queryName
     * @return
     */
    private static List<String> queryInfoCode1(String queryName) {
        List<String> resultList = Lists.newArrayList();

        String webA = searchWebA(queryName);
        resultList.add(webA);

        String webB = searchWebB(queryName);
        resultList.add(webB);

        String webC = searchWebC(queryName);
        resultList.add(webC);

        return resultList;
    }

    /**
     * 查询网站 A
     *
     * @param name
     * @return
     */
    public static String searchWebA(String name) {
        ThreadUtil.sleep(5000);
        return "webA";
    }

    /**
     * 查询网站B
     *
     * @param name
     * @return
     */
    public static String searchWebB(String name) {
        ThreadUtil.sleep(3000);
        return "webB";
    }

    /**
     * 查询网站C
     *
     * @param name
     * @return
     */
    public static String searchWebC(String name) {
        ThreadUtil.sleep(500);
        return "webC";
    }
}

你运行了一下代码,结果如下:

代码语言:javascript
代码运行次数:0
运行
复制
耗时: 8512
[webA, webB, webC]

我去,怎么请求一下要8秒多?上线了,产品还不砍死我。

debug 了一下代码,发现问题出在了请求的网站上:

代码语言:javascript
代码运行次数:0
运行
复制
    /**
     * 查询网站 A
     *
     * @param name
     * @return
     */
    public static String searchWebA(String name) {
        ThreadUtil.sleep(5000);
        return "webA";
    }

    /**
     * 查询网站B
     *
     * @param name
     * @return
     */
    public static String searchWebB(String name) {
        ThreadUtil.sleep(3000);
        return "webB";
    }

    /**
     * 查询网站C
     *
     * @param name
     * @return
     */
    public static String searchWebC(String name) {
        ThreadUtil.sleep(500);
        return "webC";
    }

网站 A、网站 B 因为年久失修,没人维护,接口响应很慢,平均响应时间一个是 5秒,一个是 3秒(这里使用 sleep 模拟)。网站 C 性能还可以,平均响应时间 0.5 秒。而我们程序的执行时间就是 网站A 响应时间 + 网站 B 响应时间 + 网站 C 响应时间。

Code 2.0

好了,问题知道了,因为请求的网站太慢了,那么如何解决呢?总不能打电话找他们把网站优化一下让我爬吧。书上教导我们要先从自己身上找问题。先看看自己代码哪里可以优化。

一分析代码发现,我们的代码全是串行化, A 网站请求完,再请求 B 网站,B 网站请求完再请求 C 网站。突然想到提高效率的第一要义,提高代码的并行率。为什么要一个一个串行请求,而不是 A、B、C 三个网站一起请求呢,Java 的多线程很轻松就可以实现,代码如下:

代码语言:javascript
代码运行次数:0
运行
复制
/*
 *
 *  * *
 *  *  * blog.coder4j.cn
 *  *  * Copyright (C) B0A6-B0B0 All Rights Reserved.
 *  *
 *
 */
package cn.coder4j.study.example.thread;

import cn.hutool.core.thread.ThreadUtil;
import com.google.common.collect.Lists;

import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author buhao
 * @version TestCompletionService.java, v 0.A B0B0-0B-A8 A9:0C buhao
 */
public class TestCompletionService {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 查询信息
        String queryName = "java";
        // 调用查询接口
        long startTime = System.currentTimeMillis();
        List<String> result = queryInfoCode2(queryName);
        System.out.println("耗时: " + (System.currentTimeMillis() - startTime));
        System.out.println(result);
    }

    /**
     * 聚合查询信息 code 1
     *
     * @param queryName
     * @return
     */
    private static List<String> queryInfoCode1(String queryName) {
        List<String> resultList = Lists.newArrayList();

        String webA = searchWebA(queryName);
        resultList.add(webA);

        String webB = searchWebB(queryName);
        resultList.add(webB);

        String webC = searchWebC(queryName);
        resultList.add(webC);

        return resultList;
    }

    /**
     * 聚合查询信息 code 2
     *
     * @param queryName
     * @return
     */
    private static List<String> queryInfoCode2(String queryName) throws ExecutionException, InterruptedException {
        List<String> resultList = Lists.newArrayList();

        // 创建3个线程的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        try {
            // 创建任务的 feature
            Future<String> webAFuture = pool.submit(() -> searchWebA(queryName));
            Future<String> webBFuture = pool.submit(() -> searchWebB(queryName));
            Future<String> webCFuture = pool.submit(() -> searchWebC(queryName));
            // 得到任务结果
            resultList.add(webAFuture.get());
            resultList.add(webBFuture.get());
            resultList.add(webCFuture.get());
        } finally {
            // 关闭线程池
            pool.shutdown();
        }
        
        return resultList;
    }

    /**
     * 查询网站 A
     *
     * @param name
     * @return
     */
    public static String searchWebA(String name) {
        ThreadUtil.sleep(5000);
        return "webA";
    }

    /**
     * 查询网站B
     *
     * @param name
     * @return
     */
    public static String searchWebB(String name) {
        ThreadUtil.sleep(3000);
        return "webB";
    }

    /**
     * 查询网站C
     *
     * @param name
     * @return
     */
    public static String searchWebC(String name) {
        ThreadUtil.sleep(500);
        return "webC";
    }
}

这里的重点代码如下:

代码语言:javascript
代码运行次数:0
运行
复制
    /**
     * 聚合查询信息 code 2
     *
     * @param queryName
     * @return
     */
    private static List<String> queryInfoCode2(String queryName) throws ExecutionException, InterruptedException {
        List<String> resultList = Lists.newArrayList();

        // 创建3个线程的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        try {
            // 创建任务的 feature
            Future<String> webAFuture = pool.submit(() -> searchWebA(queryName));
            Future<String> webBFuture = pool.submit(() -> searchWebB(queryName));
            Future<String> webCFuture = pool.submit(() -> searchWebC(queryName));
            // 得到任务结果
            resultList.add(webAFuture.get());
            resultList.add(webBFuture.get());
            resultList.add(webCFuture.get());
        } finally {
            // 关闭线程池
            pool.shutdown();
        }
        
        return resultList;
    }

请求网站的代码其实一行没变,变的是我们调用请求方法的地方,把之前串行的代码,变成了多线程的形式,而且还不是普通的多线程的形式,因为我们要在主线程获得线程的结果,所以还要使用 Future 的形式。

好的运行一下代码,看看效果,结果如下:

代码语言:javascript
代码运行次数:0
运行
复制
耗时: 5058
[webA, webB, webC]

嗯,效果明显,从 8 秒多下降到了 5 秒多,但是还是很长,没法接受的长。做为一个有追求的程序员,还要去优化。我们分析一下,刚开始代码是串行的,流程如下,总请求时间是三次请求的总时长。

然后我们优化了一下,把串行请求给并行化,流程如下:

因为是并行化,类似木桶效应,决定最长时间的因素,是你请求中最耗时的的那个操作,这里是时间为 5 秒的请求 A 网站操作。

Code 3.0

其实分析到这里,在不能优化 AB 网站的请求时间的前提下,已经很难优化了。但是方法总比困难多,我们的确没办法再去压缩总请求时间,但是可以让用户体验更好一点,这里需要引入两个技术一个是 Websocket,一个是 **CompletionService。**其中websocket 可以简单的理解成服务端推送技术,就是不需要客户端主动请求,而是通过服务端主动推送消息(ws 在本文中不是重点,会一笔带过。

代码语言:javascript
代码运行次数:0
运行
复制
 *
 *  * *
 *  *  * blog.coder4j.cn
 *  *  * Copyright (C) B0A6-B0B0 All Rights Reserved.
 *  *
 *
 */
package cn.coder4j.study.example.thread;

import cn.hutool.core.thread.ThreadUtil;
import com.google.common.collect.Lists;

import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author buhao
 * @version TestCompletionService.java, v 0.A B0B0-0B-A8 A9:0C buhao
 */
public class TestCompletionService {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 查询信息
        String queryName = "java";
        // 调用查询接口
        long startTime = System.currentTimeMillis();
        queryInfoCode3(queryName);
        System.out.println("耗时: " + (System.currentTimeMillis() - startTime));
    }

    /**
     * 聚合查询信息 code 1
     *
     * @param queryName
     * @return
     */
    private static List<String> queryInfoCode1(String queryName) {
        List<String> resultList = Lists.newArrayList();

        String webA = searchWebA(queryName);
        resultList.add(webA);

        String webB = searchWebB(queryName);
        resultList.add(webB);

        String webC = searchWebC(queryName);
        resultList.add(webC);

        return resultList;
    }

    /**
     * 聚合查询信息 code 2
     *
     * @param queryName
     * @return
     */
    private static List<String> queryInfoCode2(String queryName) throws ExecutionException, InterruptedException {
        List<String> resultList = Lists.newArrayList();

        // 创建3个线程的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        try {
            // 创建任务的 feature
            Future<String> webAFuture = pool.submit(() -> searchWebA(queryName));
            Future<String> webBFuture = pool.submit(() -> searchWebB(queryName));
            Future<String> webCFuture = pool.submit(() -> searchWebC(queryName));
            // 得到任务结果
            resultList.add(webAFuture.get());
            resultList.add(webBFuture.get());
            resultList.add(webCFuture.get());
        } finally {
            // 关闭线程池
            pool.shutdown();
        }

        return resultList;
    }

    /**
     * 聚合查询信息 code 3
     *
     * @param queryName
     * @return
     */
    private static void queryInfoCode3(String queryName) throws ExecutionException, InterruptedException {
        // 开始时间
        long startTime = System.currentTimeMillis();
        // 创建 CompletionService
        ExecutorCompletionService executorCompletionService = new ExecutorCompletionService(Executors.newFixedThreadPool(3));

        // 创建任务的 feature
        executorCompletionService.submit(() -> searchWebA(queryName));
        executorCompletionService.submit(() -> searchWebB(queryName));
        executorCompletionService.submit(() -> searchWebC(queryName));

        for (int i = 0; i < 3; i++) {
            Future take = executorCompletionService.take();
            System.out.println("获得请求结果 -> " + take.get());
            System.out.println("通过 ws 推送给客户端,总共耗时" + (System.currentTimeMillis() - startTime));
        }
    }

    /**
     * 查询网站 A
     *
     * @param name
     * @return
     */
    public static String searchWebA(String name) {
        ThreadUtil.sleep(5000);
        return "webA";
    }

    /**
     * 查询网站B
     *
     * @param name
     * @return
     */
    public static String searchWebB(String name) {
        ThreadUtil.sleep(3000);
        return "webB";
    }

    /**
     * 查询网站C
     *
     * @param name
     * @return
     */
    public static String searchWebC(String name) {
        ThreadUtil.sleep(500);
        return "webC";
    }
}

核心代码如下:

代码语言:javascript
代码运行次数:0
运行
复制
    /**
     * 聚合查询信息 code 3
     *
     * @param queryName
     * @return
     */
    private static void queryInfoCode3(String queryName) throws ExecutionException, InterruptedException {
        // 开始时间
        long startTime = System.currentTimeMillis();
        // 创建 CompletionService
        ExecutorCompletionService executorCompletionService = new ExecutorCompletionService(Executors.newFixedThreadPool(3));

        // 创建任务的 feature
        executorCompletionService.submit(() -> searchWebA(queryName));
        executorCompletionService.submit(() -> searchWebB(queryName));
        executorCompletionService.submit(() -> searchWebC(queryName));

        for (int i = 0; i < 3; i++) {
            Future take = executorCompletionService.take();
            System.out.println("获得请求结果 -> " + take.get());
            System.out.println("通过 ws 推送给客户端,总共耗时" + (System.currentTimeMillis() - startTime));
        }
    }

先看执行结果:

代码语言:javascript
代码运行次数:0
运行
复制
获得请求结果 -> webC
通过 ws 推送给客户端,总共耗时561
获得请求结果 -> webB
通过 ws 推送给客户端,总共耗时3055
获得请求结果 -> webA
通过 ws 推送给客户端,总共耗时5060
耗时: 5060

我们来分析一下执行结果,首先总耗时时间还是 5 秒多没变,但是我们不是等全部执行完再推送给客户端,而是执行完一个就推送一个,并且发现了一个规律,最先推送的是请求最快的,然后是第二快的,最后推最慢的那一个。也就是说推送结果是有序的。给用户的体验就是点击按钮后,1秒内会展示网站 C 的数据,然后过了2秒又在原有基础上又添加展示了网站 B 数据,又过了2秒,又增加展示了网站 A数据。这种体验要比用户一直白屏 5 秒,然后一下返回所有数据要好的多。

是不是很神奇,这背后的功臣就是 CompletionService,他的源码如下:

代码语言:javascript
代码运行次数:0
运行
复制
package java.util.concurrent;

/**
 * A service that decouples the production of new asynchronous tasks
 * from the consumption of the results of completed tasks.  Producers
 * {@code submit} tasks for execution. Consumers {@code take}
 * completed tasks and process their results in the order they
 * complete.  A {@code CompletionService} can for example be used to
 * manage asynchronous I/O, in which tasks that perform reads are
 * submitted in one part of a program or system, and then acted upon
 * in a different part of the program when the reads complete,
 * possibly in a different order than they were requested.
 *
 * <p>Typically, a {@code CompletionService} relies on a separate
 * {@link Executor} to actually execute the tasks, in which case the
 * {@code CompletionService} only manages an internal completion
 * queue. The {@link ExecutorCompletionService} class provides an
 * implementation of this approach.
 *
 * <p>Memory consistency effects: Actions in a thread prior to
 * submitting a task to a {@code CompletionService}
 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
 * actions taken by that task, which in turn <i>happen-before</i>
 * actions following a successful return from the corresponding {@code take()}.
 */
public interface CompletionService<V> {
    /**
     * Submits a value-returning task for execution and returns a Future
     * representing the pending results of the task.  Upon completion,
     * this task may be taken or polled.
     *
     * @param task the task to submit
     * @return a Future representing pending completion of the task
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    Future<V> submit(Callable<V> task);

    /**
     * Submits a Runnable task for execution and returns a Future
     * representing that task.  Upon completion, this task may be
     * taken or polled.
     *
     * @param task the task to submit
     * @param result the result to return upon successful completion
     * @return a Future representing pending completion of the task,
     *         and whose {@code get()} method will return the given
     *         result value upon completion
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    Future<V> submit(Runnable task, V result);

    /**
     * Retrieves and removes the Future representing the next
     * completed task, waiting if none are yet present.
     *
     * @return the Future representing the next completed task
     * @throws InterruptedException if interrupted while waiting
     */
    Future<V> take() throws InterruptedException;

    /**
     * Retrieves and removes the Future representing the next
     * completed task, or {@code null} if none are present.
     *
     * @return the Future representing the next completed task, or
     *         {@code null} if none are present
     */
    Future<V> poll();

    /**
     * Retrieves and removes the Future representing the next
     * completed task, waiting if necessary up to the specified wait
     * time if none are yet present.
     *
     * @param timeout how long to wait before giving up, in units of
     *        {@code unit}
     * @param unit a {@code TimeUnit} determining how to interpret the
     *        {@code timeout} parameter
     * @return the Future representing the next completed task or
     *         {@code null} if the specified waiting time elapses
     *         before one is present
     * @throws InterruptedException if interrupted while waiting
     */
    Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;
}

可以看到 CompletionService 方法,分别如下:

  1. Futuresubmit(Callabletask);

submit 用于提交一个 Callable 对象,用于提交一个可以获得结果的线程任务

  1. Futuresubmit(Runnable task, V result);

submit 用于提交一个 Runnable 对象及 result 对象,类似于上面的 submit,但是 runnable 的返回值 void 无法获得线程的结果,所以添加了 result 用于做为参数的桥梁

  1. Futuretake() throws InterruptedException;

take 用于取出最新的线程执行结果,注意这里是阻塞的

  1. Futurepoll();

take 用于取出最新的线程执行结果,是非阻塞的,如果没有结果就返回 null

  1. Futurepoll(long timeout, TimeUnit unit) throws InterruptedException;

同上,只是加了一个超时时间

另外,CompletionService 是接口,无法直接使用,通常使用他的实现类 ExecutorCompletionService,具体使用方法如上面的 demo。

可能看到这里会很好奇 ExecutorCompletionService 实现原理,其实原理很简单,他在内部维护了一个阻塞队列,提交的任务,先执行完的先进入队列,所以你通过 poll 或 take 获得的肯定是最先执行完的任务结果。

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2020-02-28,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 码农沉思录 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
JVM:全面解析Java对象的创建、内存布局 & 访问定位流程
由于引用类型数据(reference)在 Java虚拟机中只规定了一个指向对象的引用,但没定义该引用应该通过何种方式去定位、访问堆中的对象的具体位置
Carson.Ho
2019/10/25
1.9K0
jvm学习记录-对象的创建、对象的内存布局、对象的访问定位
简述 今天继续写《深入理解java虚拟机》的对象创建的理解。这次和上次隔的时间有些长,是因为有些东西确实不好理解,就查阅各种资料,然后弄明白了才来做记录。 (此文中所阐述的内容都是以HotSpot虚拟机为例的。) 对象的创建 java程序在运行过程中无时无刻都有对象被创建出来,那么创建对象是个怎么样的过程呢?还是看看我自己的理解吧。 判断是否已经执行类加载 当虚拟机遇到一条new指令时 ,首先去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已经被加载、解析和初始化
纪莫
2018/04/19
1.1K0
jvm学习记录-对象的创建、对象的内存布局、对象的访问定位
浅谈对象的创建、内存布局和访问定位
  这里的对象的创建是指普通的对象(不包括数组和Class对象)。对象的创建简单来说就是执行new的时候,虚拟机做出对应的响应。让我们看看一下虚拟机创建对象的过程: 1.虚拟机遇到new指令时,首先尝试在常量池中定位到对应类的符号引用,并检查这个符号引用代表类是否已被加载、解析和初始化过。如果没有,那必须先执行相应的类加载过程(后续会写一下关于类加载的问题)。 2.类加载检查通过后,为新生对象分配内存。对象内存的大小在类加载完成后便可完全确定。对象内存分配有“指针碰撞”和“空闲列表”两种方法,“指针碰撞”是把已用内存放到指针的一边,未用的放到另一边,以指针分隔,当需要分配一个新对象内存时把指针往未分配内存那边移动相对应的空间即可;“空闲列表”是因为内存已用的和未用的并不是规整的,它们是交错的,所以需要一个列表记录内存块的情况。Java堆是线程之间共享的内存,虚拟机采用CAS配上失败重试的方式保证更新操作的原子性保证内存指针修改并发安全性;另一种方法是“本地线程分配缓冲(Thread Local Allocation Buffer TLAB)”。 3.将虚拟机分配到的内存空间初始化为零值。 4.对对象进行必要的设置。其实是对对象头编写。 5.完成上面4个步骤执行new指令后会接着执行方法 到此对象才算完成生产出来。
GreizLiao
2019/09/24
8050
JVM之对象的实例化内存布局与访问定位
将对象的所属类(即类的元数据信息)、对象的HashCode和对象的GC信息、锁信息等数据存储在对象的对象头中。这个过程的具体设置方式取决于JVM实现
Java微观世界
2025/01/20
1340
JVM之对象的实例化内存布局与访问定位
JVM之对象创建流程及对象内存布局
当JAVA虚拟机碰到new字节码指令时,首先会去常量池中查找是否有对应的类名(也就是去查找是否有对应的符号引用),然后去检查这个符号引用代表的类是否已经被加载,解析和初始化过。如果没有会先进行类加载过程。
北洋
2021/12/20
5180
一文详解JVM对象内存布局以及内存分配规则
对象头可能包含类型指针,通过该指针能确定对象属于哪个类。如果对象是一个数组,那么对象头还会包括数组长度。
架构狂人
2023/08/16
5020
一文详解JVM对象内存布局以及内存分配规则
JVM02-JVM的对象创建以及访问方式
前言对象创建1.类加载检查2.分配内存分配内存的方式内存分配的并发问题3.初始化零值4.设置对象头:5. 执行init方法;对象内存布局对象头实例数据对齐填充对象访问方式使用句柄访问使用直接指针访问总结
码农飞哥
2021/08/18
5270
JVM-解密Java对象
在Java程序运行过程中时时刻刻都有对象被创建出来,对象的创建方式有很多种,最常见的就是new,其次还有clone和反序列化。下面我们一起来解密对象的创建、内存布局以及如何定位一个对象。
shysh95
2020/08/11
4080
深入理解JVM - 对象分配内存
这一节我们来讨论对象分配内存的细节,这一块的内容相对比较简单,但是也是比较重要的内容,最后会总结书里面的OOM的溢出案例,在过去的文章已经讲到过不少类似的情况。
阿东
2021/08/16
4490
JVM-02内存区域与内存溢出异常(中)【hotspot虚拟机对象】
在 JVM-01自动内存管理机制之Java内存区域与内存溢出异常(上)中我们介绍了 运行时数据区域,这里我们来继续探讨下hotspot虚拟机对象
小小工匠
2021/08/17
3780
最通俗易懂的JVM内存管理与对象创建原理
对于Java程序员来说,在虚拟机自动内存管理机制的帮助下,不再需要像 C/C++程序为每一个new操作去写配对 的delete/free代码,不容易出现内存泄漏和内存溢出问题。也正是因为Java程序员把控制内存的权力交给了Java虚拟机,一旦出现内存泄漏和溢出方面的问题,如果不了解虚拟机是怎样使用内存的,那排查错误、修正问题将会成为一项异常艰难的工作。
仲君Johnny
2024/01/24
5150
最通俗易懂的JVM内存管理与对象创建原理
JVM内存与垃圾回收篇第10章对象的实例化内存布局与访问定位
将对象的所属类(即类的元数据信息)、对象的HashCode和对象的GC信息、锁信息等数据存储在对象的对象头中。这个过程的具体设置方式取决于JVM实现。
yuanshuai
2022/08/17
2760
JVM内存与垃圾回收篇第10章对象的实例化内存布局与访问定位
JVM 中对象咋创建啊,又怎么访问啊
多学一点,这里的几个步骤涉及多个指令操作,所以就有了 DCL 单例使用 volatile 来禁止指令重排来保证单例模式的实例同步
星尘的一个朋友
2020/12/30
6660
JVM 中对象咋创建啊,又怎么访问啊
《深入理解Java虚拟机》读书笔记(二)
当Java虚拟机遇到字节码new指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已经被加载、解析和初始化过;如果没有,那么必须先执行相应的类加载过程
DestinySkywalker
2023/01/01
3760
《深入理解Java虚拟机》读书笔记(二)
深入理解JVM(③)——之HotSpot虚拟机对象探秘
上篇文章介绍了Java虚拟机的运行时数据区域,大致明白了Java虚拟机内存模型的概况,下面就基于实用优先的原则,以最常用的虚拟机HotSpot和最常用的内存区域Java堆为例,升入探讨一下HotSpot虚拟机在Java堆中对象分配、布局和访问的全过程。
纪莫
2020/06/04
6520
JVM 系列(2) —— Java 的对象
当 Java 虚拟机遇到一条字节码指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号的引用,并检查这个符号引用代表的类是否被加载解析和初始化过。如果没有则先执行相应的类加载过程。
求和小熊猫
2020/12/18
4190
JVM 系列(2) —— Java 的对象
HotSpot 虚拟机对象
虚拟机遇到一条 new 指令时,首先将去检查这个指令的参数,是否能在常量池中定位到这个类的符号引用,并且检查这个符号引用代表的类是否已被加载过、解析和初始化。如果没有,那必须先执行相应的类加载过程。
happyJared
2019/07/27
5290
JVM系列一(Java内存区域和对象创建).
线程共享,JVM中最大的一块内存,此内存的唯一目的就是存放对象实例,Java 堆是垃圾收集器管理的主要区域,因此很多时候也被称为“GC堆”(Garbage Collected Heap),可以通过 -Xmx 和 -Xms 参数来控制该区域大小。
JMCui
2019/12/02
4870
JVM系列一(Java内存区域和对象创建).
深入浅出JVM(一)之Hotspot虚拟机中的对象
对象的创建可以分为五个步骤:检查类加载,分配内存,初始化零值,设置对象头,执行实例构造器<init>
菜菜的后端私房菜
2024/09/24
3160
JVM:HotSpot虚拟机----对象的创建简单介绍及对象内存布局详解
例如:在32位HotSpot虚拟机中,如果对象处于未被锁定的状态下,那么Mark Word的32bit空间中的25bit用于存储对象哈希码,4bit用于存储对象分代年龄,2bit用于存储锁标志位,1bit固定为0。下表是不同状态下对象存储内容的详细表:
鲲志说
2025/04/07
1560
JVM:HotSpot虚拟机----对象的创建简单介绍及对象内存布局详解
推荐阅读
相关推荐
JVM:全面解析Java对象的创建、内存布局 & 访问定位流程
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档