Java简易系统监视器system-monitoring系列：增加记忆功能

最新推荐文章于 2024-05-16 14:00:00 发布
最新推荐文章于 2024-05-16 14:00:00 发布
阅读量2.3k 收藏
点赞数
分类专栏： Java简易系统监视器 Java 文章标签： java swing maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36533690/article/details/123978313
版权

Java简易系统监视器system-monitoring：实时显示CPU使用率、内存使用率、电脑电池剩余电量、时间（时、分、秒）。创建系统托盘，设置系统托盘菜单，窗体置顶显示。通过jna调用dll文件读取电池数据。

目录

前言

技术点

核心代码

Properties.java

AppUtil.java

cxzgwing.Menu#setLayoutJMenu

cxzgwing.listener.FrameDragListener#mouseReleased

pom.xml

GitHub

Gitee

参考链接

前言

由于system-monitoring之前的版本是每次启动后会重置为默认布局，为了方便使用，特增加记忆功能。当修改布局、显示标签以及移动窗体位置之后，会记录修改后的状态，以便在下次启动时恢复该状态。

技术点

1、思路：每当修改布局、显示标签以及移动窗体位置之后，记录相关参数，写入配置文件。当创建窗体时，读取配置文件，根据配置参数设置窗体。若无配置文件，则置为默认布局。

2、增加了日志记录。

3、依赖：slf4j、logback、fastjson、lombok。

核心代码

Properties.java

package cxzgwing.model;

import java.util.HashMap;
import java.util.Map;

import com.alibaba.fastjson.annotation.JSONField;

import cxzgwing.utils.Constants;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

@Data
@EqualsAndHashCode
@ToString
public class Properties {
    // 1-单列布局 2-双列布局（默认）
    @JSONField(name = "layout")
    private int layout;

    // 显示标签：1-CPU 2-Memory 3-Battery 4-Time 默认全选
    @JSONField(name = "display")
    private Map<String, Boolean> displayMap;

    @JSONField(name = "x")
    private int x;
    @JSONField(name = "y")
    private int y;

    public Properties() {
        this.layout = 2;
        // 窗体默认在屏幕右下角，x和y均设置为-1
        this.x = -1;
        this.y = -1;
        this.displayMap = new HashMap<>();
        this.displayMap.put(Constants.FIELD_CPU, true);
        this.displayMap.put(Constants.FIELD_MEMORY, true);
        this.displayMap.put(Constants.FIELD_BATTERY, true);
        this.displayMap.put(Constants.FIELD_TIME, true);
    }

    @JSONField(serialize = false, deserialize = false)
    public boolean isSingleLayout() {
        return this.layout == Constants.Single_Layout;
    }

    @JSONField(serialize = false, deserialize = false)
    public boolean isDoubleLayout() {
        return this.layout == Constants.Double_Layout;
    }

    @JSONField(serialize = false, deserialize = false)
    public boolean isCpuDisplay() {
        return this.displayMap.get(Constants.FIELD_CPU);
    }

    @JSONField(serialize = false, deserialize = false)
    public boolean isMemoryDisplay() {
        return this.displayMap.get(Constants.FIELD_MEMORY);
    }

    @JSONField(serialize = false, deserialize = false)
    public boolean isBatteryDisplay() {
        return this.displayMap.get(Constants.FIELD_BATTERY);
    }

    @JSONField(serialize = false, deserialize = false)
    public boolean isTimeDisplay() {
        return this.displayMap.get(Constants.FIELD_TIME);
    }

    @JSONField(serialize = false, deserialize = false)
    public void put(String name, boolean isDisplay) {
        this.displayMap.put(name, isDisplay);
    }

}

AppUtil.java

package cxzgwing.utils;

import java.awt.*;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.sun.management.OperatingSystemMXBean;

import cxzgwing.Window;
import cxzgwing.dll.Dll;
import cxzgwing.model.Properties;

public class AppUtil {
    private static final Logger logger = LoggerFactory.getLogger(AppUtil.class);
    private static OperatingSystemMXBean systemMXBean;
    static {
        systemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
    }

    public static String getTime() {
        return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));
    }

    public static String getMemoryLoad() {
        double totalPhysicalMemorySize = systemMXBean.getTotalPhysicalMemorySize();
        double freePhysicalMemorySize = systemMXBean.getFreePhysicalMemorySize();
        double value = freePhysicalMemorySize / totalPhysicalMemorySize;
        return "M: " + String.format("%.1f", (1 - value) * 100) + "%";
    }

    public static String getSystemCpuLoad() {
        return "C: " + String.format("%.1f", systemMXBean.getSystemCpuLoad() * 100) + "%";
    }

    public static String getBatteryPercent() {
        int value = 225;
        try {
            value = Dll.dll.BatteryPercent();
        } catch (Exception e) {
            logger.error("getBatteryPercent error", e);
        }
        return "B: " + value + "%";
    }

    public static void initWindowLocation(Window window, Properties properties) {

        // 获得窗体宽
        int windowWidth = window.getWidth();
        // 获得窗体高
        int windowHeight = window.getHeight();
        // 定义工具包
        Toolkit kit = Toolkit.getDefaultToolkit();
        // 获取屏幕的尺寸
        Dimension screenSize = kit.getScreenSize();
        // 获取屏幕的宽
        int screenWidth = screenSize.width;
        // 获取屏幕的高
        int screenHeight = screenSize.height;
        // 获取任务栏
        Insets screenInsets = kit.getScreenInsets(window.getGraphicsConfiguration());
        // 获取窗体边界位置
        int windowMaxX = screenWidth - windowWidth;
        int windowMaxY = screenHeight - windowHeight - screenInsets.bottom;
        window.setWindowMaxX(windowMaxX);
        window.setWindowMaxY(windowMaxY);
        // 设置窗体位置坐标
        int x;
        int y;
        int propertiesX = properties.getX();
        if (propertiesX > -1 && propertiesX <= windowMaxX) {
            x = propertiesX;
        } else {
            x = windowMaxX;
        }
        int propertiesY = properties.getY();
        if (propertiesY > -1 && propertiesY <= windowMaxY) {
            y = propertiesY;
        } else {
            y = windowMaxY;
        }

        // 设置窗口相对于指定组件的位置：置于屏幕的中央
        // frame.setLocationRelativeTo(null);

        // 设置窗体位置（默认在屏幕右下角）
        if (x != window.getX() || y != window.getY()) {
            window.setLocation(x, y);
        }
    }

    public static Properties getProperties() {
        Properties properties;
        String propertiesPath = getPropertiesPath();
        String content = readFile(propertiesPath);
        if (StringUtils.isBlank(content)) {
            properties = new Properties();
            writeFile(propertiesPath, properties, false);
        } else {
            properties = JSON.parseObject(content, Properties.class);
        }
        return properties;
    }

    public static String readFile(String path) {
        String value = "";
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        try {
            File file = new File(path);
            if (file.exists()) {
                fileReader = new FileReader(file);
                bufferedReader = new BufferedReader(fileReader);
                StringBuilder stringBuilder = new StringBuilder();
                String s;
                while ((s = bufferedReader.readLine()) != null) {
                    stringBuilder.append(s);
                }
                value = stringBuilder.toString();
            }
        } catch (Exception e) {
            logger.error("readFile error, return empty string", e);
        } finally {
            closeResource(bufferedReader);
            closeResource(fileReader);
        }
        return value;
    }

    public static boolean writeFile(String filePath, Object o, boolean append) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(filePath, append);
            fos.write(JSON.toJSONString(o).getBytes());
            return true;
        } catch (Exception e) {
            logger.error("writeFile error", e);
            return false;
        } finally {
            closeResource(fos);
        }
    }

    private static void closeResource(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                logger.error("closeResource error", e);
            }
        }
    }

    public static String getPropertiesPath() {
        String folder = getCurrentFolder();
        return folder + "properties.conf";
    }

    /**
     * 获取程序当前所在的文件夹
     * 
     * @return eg:/E:/Projects/GitHub/MyProjects/system-monitoring/target/classes/
     */
    private static String getCurrentFolder() {
        String locationPath =
                AppUtil.class.getProtectionDomain().getCodeSource().getLocation().getPath();
        if (locationPath.toUpperCase().contains(".JAR")) {
            // 截取.JAR第一次出现前的字符串
            String StrPath = locationPath.substring(0, locationPath.toUpperCase().indexOf(".JAR"));
            // 获取jar包的上一层文件夹
            locationPath = StrPath.substring(0, StrPath.lastIndexOf(File.separator) + 1);
        } else if (locationPath.toUpperCase().contains(".EXE")) {
            String StrPath = locationPath.substring(0, locationPath.toUpperCase().indexOf(".EXE"));
            locationPath = StrPath.substring(0, StrPath.lastIndexOf(File.separator) + 1);
        }
        return locationPath;
    }

    public static GridLayout initLayout(int displayLabelCount, Properties properties,
            Window window) {
        GridLayout gridLayout = null;
        if (properties.isSingleLayout()) {
            // 单列布局
            window.setLayout(gridLayout = new GridLayout(displayLabelCount, 1));
            window.setSize(75, 20 * displayLabelCount);
        } else if (properties.isDoubleLayout()) {
            // 双列布局
            switch (displayLabelCount) {
                case 1:
                    window.setLayout(gridLayout = new GridLayout(1, 1));
                    window.setSize(75, 20);
                    break;
                case 2:
                    window.setLayout(gridLayout = new GridLayout(1, 2));
                    window.setSize(150, 20);
                    break;
                case 3:
                case 4:
                    window.setLayout(gridLayout = new GridLayout(2, 2));
                    window.setSize(150, 40);
                    break;
                default:
                    window.setLayout(gridLayout = new GridLayout(2, 2));
                    window.setSize(150, 40);
            }
        }
        return gridLayout;
    }
}

cxzgwing.Menu#setLayoutJMenu

 private void setLayoutJMenu() {
        JMenu layoutJMenu = new JMenu("布局");
        layoutJMenu.setFont(font);
        JMenuItem singleJMenuItem = new JMenuItem("单列布局");
        singleJMenuItem.setFont(font);
        singleJMenuItem.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                properties.setLayout(Constants.Single_Layout);
                AppUtil.writeFile(AppUtil.getPropertiesPath(), properties, false);
                window.setSize(85, 80);
                window.setLayout(new FlowLayout(FlowLayout.LEFT, 5, 1));
                reloadWindow();
                AppUtil.initWindowLocation(window, properties);
                refreshWindow();
            }
        });
        JMenuItem doubleJMenuItem = new JMenuItem("双列布局");
        doubleJMenuItem.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                properties.setLayout(Constants.Double_Layout);
                AppUtil.writeFile(AppUtil.getPropertiesPath(), properties, false);
                window.setSize(150, 40);
                window.setLayout(new GridLayout(2, 2));
                reloadWindow();
                AppUtil.initWindowLocation(window, properties);
                refreshWindow();
            }
        });
        doubleJMenuItem.setFont(font);
        layoutJMenu.add(singleJMenuItem);
        layoutJMenu.add(doubleJMenuItem);
        jPopupMenu.add(layoutJMenu);
    }

cxzgwing.listener.FrameDragListener#mouseReleased

    @Override
    public void mouseReleased(MouseEvent e) {
        mouseDownCompCoords = null;
        if (this.windowMovable.isTrue()
                && (properties.getX() != window.getX() || properties.getY() != window.getY())) {
            properties.setX(window.getX());
            properties.setY(window.getY());
            try {
                AppUtil.writeFile(AppUtil.getPropertiesPath(), properties, false);
            } catch (Exception ex) {
                ex.printStackTrace();
                logger.error("mouseReleased error", ex);
            }
        }
    }

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cxzgwing</groupId>
    <artifactId>system-monitoring</artifactId>
    <version>2.1.0</version>

    <name>system-monitoring</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/net.java.dev.jna/jna -->
        <dependency>
            <groupId>net.java.dev.jna</groupId>
            <artifactId>jna</artifactId>
            <version>5.5.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.80</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

    </dependencies>

    <build>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
                <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
                <plugin>
                    <artifactId>maven-site-plugin</artifactId>
                    <version>3.7.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-project-info-reports-plugin</artifactId>
                    <version>3.0.0</version>
                </plugin>
            </plugins>
        </pluginManagement>

        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>cxzgwing.App</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

GitHub

GitHub - cxzgwing/system-monitoring: Java Swing applet, real-time monitoring system CPU usage and memory usage.

Gitee

system-monitoring: Java Swing applet, real-time monitoring system CPU usage and memory usage.​​​​​​

参考链接

[1] 拼命三郎bai.JAVA 获取JAR包所在的文件夹.2014-12-11 22:26
https://www.cnblogs.com/MBai/p/4158646.html

[2] 凡心.Java Logging 日志框架 SLF4J 的使用（Maven）.2020年06月09日 17:18
https://juejin.cn/post/6844904184492326926

[3] 疯狂哈丘.logback配置详解 & 原理介绍.2018-09-01 13:45:16
https://blog.csdn.net/u013332124/article/details/82286573

[4] 刚入门的小小白.addShutdownHook ---程序出错退出终极处理办法（转）.2018-08-27 11:10:00
https://blog.csdn.net/qq_38238217/article/details/82109090

[5] 菜鸟教程.Fastjson 简明教程
https://www.runoob.com/w3cnote/fastjson-intro.html

晨曦之光Wing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Monitoring:监视使用Java，ElasticSearch和Grafana开发的ENSISA机械工讲习班
05-13
监控方式 监视由Java，ElasticSearch和Grafana开发的ENSISA机械车间。 首先，您需要： 1-要从以下链接安装ElasticSearch： ://www.elastic.co/fr/downloads/elasticsearch。 有关如何安装的更多信息： : 2-通过以下链接安装Grafana： ://grafana.com/grafana/download。 如何使用 ： 在主类Monitoring.java中，您可以加载与JSON格式兼容的配置文件（.txt），也可以创建配置： //By file MonitoringConfiguration config = new MonitoringConfiguration("...\\config.txt"); //With default constructor MonitoringConfig
linux-system-monitor：Linux系统监视器-显示Linux任务
02-04
Linux系统监视器是一款用于实时监控Linux系统状态的工具，它能够提供有关系统任务、进程、资源使用情况等信息。在Linux环境中，理解并监控系统的运行状况对于系统管理员来说至关重要，因为这有助于诊断性能问题、...
Java简易系统监视器system-monitoring
晨曦之光Wing的博客
01-18 1948
Java简易系统监视器system-monitoring：实时显示CPU使用率、内存使用率、笔记本电脑电池剩余电量、时间（时、分、秒）。创建系统托盘，设置系统托盘菜单，窗体置顶显示。通过jna调用dll文件读取电池数据。 目录 效果图 功能说明 项目与工具 项目说明 目录结构 核心代码 Window.java Menu.java Dll.java AppUtil.java BatteryLabel.java C++创建dll BatteryMonitor.h BatteryMo
java 溯本求源之基础（十九）之Monitoring--jconsole
最新发布
程序员LSP
05-16 1466
本文介绍了Java管理工具JConsole的主要功能和应用场景。JConsole能够实时监控Java应用的关键性能指标，如内存使用、CPU负载和线程状态，帮助开发者及时发现并解决性能问题，优化应用性能。文章通过具体实例展示了如何使用JConsole监控和诊断Java应用，突出了其在性能调优和系统健康监控中的重要作用。JConsole作为一个不可或缺的工具，对提升Java应用的稳定性和效率具有重要意义。
JAVA中用动态代理类实现记忆功能(二)
热门推荐
键者天行
08-05 1万+
通过动态代理类来创建一个通用的缓存包装器   上面第二种方法仅有的缺点就是缓存包装器不能重用,每次我们希望添加一个缓存给某个类,我们就要写一个特殊的缓存包装器给目标接口.这是一个很慢,容易出错的过程.     Jdk1.3开始支持动态代理类: 特别的类能够在运行期决定实现哪个接口-通常的模式都是,在运行期即决定实现哪个接口.通过这个,我们有可能实现一个通用的缓存包装器,我们称它为Mem
java实现记忆功能（由于作者”挨踢老人“的主页上广告看着很不舒服所以住贴到这里）
Macroli
11-17 1262
记忆是衍生自lisp,python,和perl等过程性语言的一种设计模式，它可以对前次的计算结果进行记忆。 一个实现了记忆功能的函数, 带有显式的cache, 所以, 已经计算过的结果就能直接从cache中获得, 而不用每次都进行计算.　　记忆能显著的提升大计算量代码的效率. 而且是一种可重用的方案.　　本文阐述了在java中使用这一模式的方法,并提供了一个可以提供上述功能的"记忆类":
nginx-rtmp-monitoring：nginx rtmp模块的实时监视统计信息显示板
02-03
fstv监控 带有实时监控仪表板的rtmp＆hls服务器。 如何安装 chmod +x setup.sh && ./setup.sh 登录到仪表板 在浏览器中打开 登录的默认凭据： ... docker exec -it fstv_dashboard cat /usr/src/app/config.json ...
deepin-system-monitor:系统监视器的深度
05-19
深度系统监控器深度系统监控器：更加用户友好的系统监控器。 非常感谢的工作，该项目使用了许多代码。依存关系sudo apt安装libpcap-dev libncurses5-dev libprocps-dev libxtst-dev libxcb-util0-dev安装mkdir构建...
ros-system-monitor:ROS的系统监视工具
03-11
罗斯系统监控器概要ROS的系统监视工具。 作者： Willow Garage，Inc.，杰罗姆·梅（Jerome Maye），拉尔夫·凯斯特纳（Ralf Kaestner） 维护者： Ralf Kaestner 许可证： BSD许可证（BSD） 操作系统：基于Debian...
System-Monitor:系统监视器，使用Socket.IO，Express，Cron创建
05-16
系统监视器，使用Socket.IO，Express，Cron创建 当客户端连接到应用程序服务器时，将建立新的套接字连接，并开始cron作业。 服务器根据config.js发送系统信息，默认情况下每10秒发送一次所有信息。 您可以通过编辑...
java monitoring_七、jdk工具之jconsole命令(Java Monitoring and Management Console)
weixin_35964164的博客
02-16 261
目录jconsole:一个javaGUI监视工具，可以以图表化的形式显示各种数据。并可通过远程连接监视远程的服务器VM。用java写的GUI程序，用来监控VM，并可监控远程的VM，非常易用，而且功能非常强。命令行里打jconsole，选则进程就可以了。需要注意的就是在运行jconsole之前，必须要先设置环境变量DISPLAY，否则会报错误，Linux下设置环境变量如下：exportDISP...
[深入理解Java虚拟机]第四章 虚拟机性能监控与故障处理工具
Code-lover's Learning Notes
10-06 5393
理论总是作为指导实践的工具,能把这些知识应用到实际工作中才是 我们的最终目的。给一个系统定位问题的时候,知识、经验是关键基础,数据是依据,工具是运用知识处理数据的手段。这里说的数据包括:运行日志、异常堆栈、GC日志、线程快照 ( threaddump/javacore文件)、堆转储快照(heapdump/hprof文件)等。经常使用适当的虚拟机监控和分析的工具可以加快我们分析数据、定位解决问题的速
JavaMonitor 监视器
sinolover的专栏
07-08 1496
为什么wait(), notify()和notifyAll()必须在同步方法或者同步块中被调用？ 当一个线程需要调用对象的wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁并进入等待状态直到其他线程调用这个对象上的notify()方法。同样的，当一个线程需要调用对象的notify()方法时，它会释放这个对象的锁，以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方...
Java简易系统监视器
晨曦之光Wing的博客
06-13 1943
Java实时监控CPU使用率和内存使用率
Java中的Monitor
qq_46130027的博客
07-14 2137
在Java中，Monitor（监视器）是一种同步机制，用于管理多线程之间的互斥访问和并发控制。
Java monitor
xiafangxingg的博客
05-05 1906
在Java中使用线程同步来解决线程竞争的问题。但是有些方法使用还是需要有些注意点，这里我们主要来谈一下Object 类中的wait和notify/notifyAll 方法。首先这两个方法使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用 (而Thread中的sleep可以在任何地方使用) synchronized(x){ 　　x.notify() 　　//或
Java——同步监视器
Cherry的博客
04-02 2105
package day04; /** * 有效的缩小同步范围可以在保证并发安全的前提下尽可 * 能提高并发效率。 * * 同步块可以更准确的控制需要同步运行的代码片段。 * synchronized(同步监视器) { * 需要同步运行的代码片段 * } * * 同步监视器是java中任意的一个对象，只要保证多个线程 * 看到的该对象是“同一个”,即可保证同步块中的代码是...
java对象监视器
qq_45811926的博客
10-09 211
HotSpot虚拟机中，对象在内存中存储的布局可以分为三块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。对象头包含两部分：运行时元数据（Mark Word）和类型指针（Klass Word）。对象监视器（监视器锁、对象锁、内部锁）是对象的逻辑结构。: 锁状态标志 (用于JDK1.6对synchronized的优化 -> 轻量级锁)四、object类中的wait()、notify()、notifyAll()等方法。: 重量级锁对应监视器对象的指针。
三菱通用AC伺服MR-JE-A系列：安全操作与功能结构详解
本文主要介绍的是三菱伺服系统中的功能结构图，特别是MR-JE系列的伺服放大器。MR-JE系列伺服包括不同的型号，如MR-JE-100A及其以下型号，其中需要注意的是MR-JE-10A和MR-JE-20A内并未内置再生电阻器。当使用单相AC ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值