常见 Java 代码缺陷及规避方式

深入解析Java代码缺陷管理:从流程到实践的全面指南 通过这篇文章,我们不仅深入了解了Java代码缺陷管理的重要性,还学习了如何利用现代工具和技术来提升我们的工作效率。记住,良好的缺陷管理不仅仅是一套流程或工具的集合,它更是一种文化,一种追求卓越的态度。希望这篇文章能为你的日常开发工作带来启发,并助你在未来的项目中取得更大的成功。如果你有任何疑问或者想要分享的经验,请随时留言讨论。现在就开始行动吧,看看你能否在下一个项目中应用这些概念! 阅读详情

在日常开发过程中,我们会碰到各种各样的代码缺陷或者 Bug,比如 NPE、 线程安全问题、异常处理等。这篇文章总结了一些常见的问题及应对方案,希望能帮助到大家。

问题列表

空指针异常

NPE 或许是编程语言中最常见的问题,被 Null 的发明者托尼·霍尔(Tony Hoare)称之为十亿美元的错误。在 Java 中并没有内置的处理 Null 值的语法,但仍然存在一些相对优雅的方式能够帮助我们的规避 NPE。

  • 使用 JSR-305/jetbrain 等注解
  1. NotNull

  2. Nullable

图片

通过在方法参数、返回值、字段等位置显式标记值是否可能为 Null,配合代码检查工具,能够在编码阶段规避绝大部分的 NPE 问题,建议至少在常用方法或者对外 API 中使用该注解,能够对调用方提供显著的帮助。

  • 用 Optional 处理链式调用

Optional 源于 Guava 中的 Optional 类,后 Java 8 内置到 JDK 中。Optional 一般作为函数的返回值,强制提醒调用者返回值可能不存在,并且能够通过链式调用优雅的处理空值。

public class OptionalExample {
    public static void main(String[] args) {        // 使用传统空值处理方式        User user = getUser();        String city = "DEFAULT";        if (user != null && user.isValid()) {            Address address = user.getAddress();            if (adress != null) {                city = adress.getCity();            }        }        System.out.println(city);
        // 使用 Optional 的方式        Optional<User> optional = getUserOptional();        city = optional.filter(User::isValid)                .map(User::getAddress)            .map(Adress::getCity)              .orElse("DEFAULT")        System.out.println(city);    }
    @Nullable    public static User getUser() {        return null;    }
    public static Optional<User> getUserOptional() {        return Optional.empty();    }
    @Data    public static class User {        private Adress address;        private boolean valid;    }
    @Data    public static class Address {        private String city;    }}
  • 用 Objects.equals(a,b) 代替 a.equals(b)

equals方法是 NPE 的高发地点,用 Objects.euqals来比较两个对象,能够避免任意对象为 null 时的 NPE。

  • 使用空对象模式

空对像模式通过一个特殊对象代替不存在的情况,代表对象不存在时的默认行为模式。常见例子:

用 Empty List 代替 null,EmptyList 能够正常遍历:

public class EmptyListExample {
    public static void main(String[] args) {        List<String> listNullable = getListNullable();        if (listNullable != null) {            for (String s : listNullable) {                System.out.println(s);            }        }
        List<String> listNotNull = getListNotNull();        for (String s : listNotNull) {            System.out.println(s);        }    }
    @Nullable    public static List<String> getListNullable() {        return null;    }
    @NotNull    public static List<String> getListNotNull() {        return Collections.emptyList();    }}

空策略​​​​​​​

public class NullStrategyExample {
    private static final Map<String, Strategy> strategyMap = new HashMap<>();
    public static void handle(String strategy, String content) {        findStrategy(strategy).handle(content);    }
    @NotNull    private static Strategy findStrategy(String strategyKey) {        return strategyMap.getOrDefault(strategyKey, new DoNothing());    }
    public interface Strategy {        void handle(String s);    }
    // 当找不到对应策略时, 什么也不做    public static class DoNothing implements Strategy {        @Override        public void handle(String s) {
        }    }}

对象转化

在业务应用中,我们的代码结构往往是多层次的,不同层次之间经常涉及到对象的转化,虽然很简单,但实际上繁琐且容易出错。

反例 1:​​​​​​​

public class UserConverter {
    public static UserDTO toDTO(UserDO userDO) {        UserDTO userDTO = new UserDTO();        userDTO.setAge(userDO.getAge());        // 问题 1: 自己赋值给自己        userDTO.setName(userDTO.getName());        return userDTO;    }
    @Data    public static class UserDO {        private String name;        private Integer age;        // 问题 2: 新增字段未赋值        private String address;    }
    @Data    public static class UserDTO {        private String name;        private Integer age;    }}

反例2:​​​​​​​

public class UserBeanCopyConvert {
    public UserDTO toDTO(UserDO userDO) {        UserDTO userDTO = new UserDTO();        // 用反射复制不同类型对象.        // 1. 重构不友好, 当我要删除或修改 UserDO 的字段时, 无法得知该字段是否通过反射被其他字段依赖        BeanUtils.copyProperties(userDO, userDTO);        return userDTO;    }}
  • 使用 Mapstruct

Mapstruct 使用编译期代码生成技术,根据注解, 入参,出参自动生成转化,代码,并且支持各种高级特性,比如:

  1. 未映射字段的处理策略,在编译期发现映射问题;

  2. 复用工具,方便字段类型转化;

  3. 生成 spring Component 注解,通过 spring 管理;

  4. 等等其他特性;

@Mapper(    componentModel = "spring",    unmappedSourcePolicy = ReportingPolicy.ERROR,    unmappedTargetPolicy = ReportingPolicy.ERROR,    // convert 逻辑依赖 DateUtil 做日期转化    uses = DateUtil.class)public interface UserConvertor  {
    UserDTO toUserDTO(UserDO userDO);
    @Data    class UserDO {        private String name;        private Integer age;        //private String address;        private Date birthDay;    }
    @Data    class UserDTO {        private String name;        private Integer age;        private String birthDay;    }
}
public class DateUtil {    public static String format(Date date) {        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");        return simpleDateFormat.format(date);    }}

使用示例:​​​​​​​

@RequiredArgsConstructor@Componentpublic class UserService {    private final UserDao userDao;    private final UserCovertor userCovertor;
    public UserDTO getUser(String userId){        UserDO userDO = userDao.getById(userId);        return userCovertor.toUserDTO(userDO);    }}

编译期校验:

图片

生成的代码:​​​​​​​

@Generated(    value = "org.mapstruct.ap.MappingProcessor",    date = "2023-12-18T20:17:00+0800",    comments = "version: 1.3.1.Final, compiler: javac, environment: Java 11.0.12 (GraalVM Community)")@Componentpublic class UserConvertorImpl implements UserConvertor {
    @Override    public UserDTO toUserDTO(UserDO userDO) {        if ( userDO == null ) {            return null;        }
        UserDTO userDTO = new UserDTO();
        userDTO.setName( userDO.getName() );        userDTO.setAge( userDO.getAge() );        userDTO.setBirthDay( DateUtil.format( userDO.getBirthDay() ) );
        return userDTO;    }}

线程安全问题

JVM 的内存模型十分复杂,难以理解, <<Java 并发编程实战>>告诉我们,除非你对 JVM 的线程安全原理十分熟悉,否则应该严格遵守基本的 Java 线程安全规则,使用 Java 内置的线程安全的类及关键字。

  • 熟练使用线程安全类

ConcurrentHashMap

反例:

map.get 以及 map.put 操作是非原子操作,多线程并发修改的情况下可能导致一致性问题。比如线程 A 调用 append 方法,在第 6 行时,线程 B 删除了 key。​​​​​​​

public class ConcurrentHashMapExample {    private Map<String, String> map = new ConcurrentHashMap<>();
    public void appendIfExists(String key, String suffix) {        String value = map.get(key);        if (value != null) {            map.put(key, value + suffix);        }    }}

正例:​​​​​​​

public class ConcurrentHashMapExample {    private Map<String, String> map = new ConcurrentHashMap<>();
    public void append(String key, String suffix) {        // 使用 computeIfPresent 原子操作        map.computeIfPresent(key, (k, v) -> v + suffix);    }}
  • 保证变更的原子性

反例:​​​​​​​

@Getterpublic class NoAtomicDiamondParser {
    private volatile int start;
    private volatile int end;
    public NoAtomicDiamondParser() {        Diamond.addListener("dataId", "groupId", new ManagerListenerAdapter() {            @Override            public void receiveConfigInfo(String s) {                JSONObject jsonObject = JSON.parseObject(s);                start = jsonObject.getIntValue("start");                end  = jsonObject.getIntValue("end");            }        });    }}
public class MyController{
    private final NoAtomicDiamondParser noAtomicDiamondParser;
    public void handleRange(){        // end 读取的旧值, start 读取的新值, start 可能大于 end        int end = noAtomicDiamondParser.getEnd();        int start = noAtomicDiamondParser.getStart();    }}

正例:​​​​​​​

@Getterpublic class AtomicDiamondParser {
    private volatile Range range;
    public AtomicDiamondParser() {        Diamond.addListener("dataId", "groupId", new ManagerListenerAdapter() {            @Override            public void receiveConfigInfo(String s) {                range = JSON.parseObject(s, Range.class);            }        });    }
    @Data    public static class Range {        private int start;        private int end;    }}
public class MyController {
    private final AtomicDiamondParser atomicDiamondParser;
    public void handleRange() {        Range range = atomicDiamondParser.getRange();        System.out.println(range.getStart());        System.out.println(range.getEnd());    }}
  • 使用不可变对象

当一个对象是不可变的,那这个对象内就自然不存在线程安全问题,如果需要修改这个对象,那就必须创建一个新的对象,这种方式适用于简单的值对象类型,常见的例子就是 java 中的 String 和 BigDecimal。对于上面一个例子,我们也可以将 Range 设计为一个通用的值对象。

正例:​​​​​​​

@Getterpublic class AtomicDiamondParser {
    private volatile Range range;
    public AtomicDiamondParser() {        Diamond.addListener("dataId", "groupId", new ManagerListenerAdapter() {            @Override            public void receiveConfigInfo(String s) {                JSONObject jsonObject = JSON.parseObject(s);                int start = jsonObject.getIntValue("start");                int end  = jsonObject.getIntValue("end");                range = new Range(start, end);            }        });    }
    // lombok 注解会保证 Range 类的不变性    @Value    public static class Range {        private int start;        private int end;    }}
  • 正确性优先于性能

不要因为担心性能问题而放弃使用 synchronized,volatile 等关键字,或者采用一些非常规写法。

反例 双重检查锁:​​​​​​​

class Foo {   // 缺少 volatile 关键字  private Helper helper = null;  public Helper getHelper() {    if (helper == null)       synchronized(this) {        if (helper == null)           helper = new Helper();      }        return helper;    }}

在上述例子中,在 helper 字段上增加 volatile 关键字,能够在 java 5 及之后的版本中保证线程安全。

正例:​​​​​​​

class Foo {   private volatile Helper helper = null;  public Helper getHelper() {    if (helper == null)       synchronized(this) {        if (helper == null)           helper = new Helper();      }        return helper;    }}

正例3(推荐):​​​​​​​

class Foo {   private Helper helper = null;  public synchronized Helper getHelper() {      if (helper == null)           helper = new Helper();      }        return helper;}

并不严谨的 Diamond Parser:​​​​​​​

/** * 省略异常处理等其他逻辑 */@Getterpublic class DiamondParser {
    // 缺少 volatile 关键字    private Config config;
    public DiamondParser() {        Diamond.addListener("dataId", "groupId", new ManagerListenerAdapter() {            @Override            public void receiveConfigInfo(String s) {                config = JSON.parseObject(s, Config.class);            }        });    }
    @Data    public static class Config {        private String name;    }}

这种 Diamond 写法可能从来没有发生过线上问题,但这种写法也确实是不符合 JVM 线程安全原则。未来某一天你的代码跑在另一个 JVM 实现上,可能就有问题了。

线程池使用不当

反例 1:​​​​​​​

public class ThreadPoolExample {
    // 没有任何限制的线程池, 使用起来很方便, 但当一波请求高峰到达时, 可能会创建大量线程, 导致系统崩溃    private static Executor executor = Executors.newCachedThreadPool();
}

反例 2:

public class StreamParallelExample {
    public List<String> batchQuery(List<String> ids){        // 看上去很优雅, 但 ForkJoinPool 的队列是没有大小限制的, 并且线程数量很少, 如果 ids 列表很大可能导致 OOM        // parallelStream 更适合计算密集型任务, 不要在任务中做远程调用        return ids.parallelStream()            .map(this::queryFromRemote)            .collect(Collectors.toList());    }
    private String queryFromRemote(String id){       // 从远程查询    }}
  • 手动创建线程池

正例:​​​​​​​

public class ManualCreateThreadPool {
    // 手动创建资源有限的线程池    private Executor executor = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(1000),        new ThreadFactoryBuilder().setNameFormat("work-%d").build());}

异常处理不当

和 NPE 一样,异常处理也同样是我们每天都需要面对的问题,但很多代码中往往会出现:

反例 1:

重复且繁琐的的异常处理逻辑​​​​​​​

@Slf4jpublic class DuplicatedExceptionHandlerExample {
    private UserService userService;
    public User query(String id) {        try {            return userService.query(id);        } catch (Exception e) {            log.error("query error, userId: {}", id, e);            return null;        }    }
    public User create(String id) {        try {            return userService.create(id);        } catch (Exception e) {            log.error("query error, userId: {}", id, e);            return null;        }    }}

反例 2:

异常被吞掉或者丢失部分信息​​​​​​​

@Slf4jpublic class ExceptionShouldLogOrThrowExample {
    private UserService userService;
    public User query(String id) {        try {            return userService.query(id);        } catch (Exception e) {            // 异常被吞并, 问题被隐藏            return null;        }    }
    public User create(String id) {        try {            return userService.create(id);        } catch (Exception e) {            // 堆栈丢失, 后续难以定位问题            log.error("query error, userId: {}, error: {}", id,e.getMessage() );            return null;        }    }}

反例 3:

对外抛出未知异常, 导致调用方序列化失败​​​​​​​

public class OpenAPIService {
    public void handle(){        // HSF 服务对外抛出 client 中未定义的异常, 调用方反序列化失败        throw new InternalSystemException("");    }}
  • 通过 AOP 统一异常处理
  1. 避免未知异常抛给调用方, 将未知异常转为 Result 或者通用异常类型

  2. 统一异常日志的打印和监控

  • 处理 Checked Exception

Checked Exception 是在编译期要求必须处理的异常,也就是非 RuntimeException 类型的异常,但 Java Checked 的异常给接口的调用者造成了一定的负担,导致异常声明层层传递,如果顶层能够处理该异常,我们可以通过 lombok 的 @SneakyThrows 注解规避 Checked exception。

图片

  • Try catch 线程逻辑

反例:​​​​​​​

@RequiredArgsConstructorpublic class ThreadNotTryCatch {    private final ExecutorService executorService;    public void handle() {        executorService.submit(new Runnable() {            @Override            public void run() {                // 未捕获异常, 线程直接退出, 异常信息丢失                remoteInvoke();            }        });    }}

正例:​​​​​​​

@RequiredArgsConstructor@Slf4jpublic class ThreadNotTryCatch {    private final ExecutorService executorService;
    public void handle() {        executorService.submit(new Runnable() {            @Override            public void run() {                try {                    remoteInvoke();                } catch (Exception e) {                    log.error("handle failed", e);                }            }        });    }}
  • 特殊异常的处理

InterruptedException 一般是上层调度者主动发起的中断信号,例如某个任务执行超时,那么调度者通过将线程置为 interuppted 来中断任务,对于这类异常我们不应该在 catch 之后忽略,应该向上抛出或者将当前线程置为 interuppted。

反例:​​​​​​​

public class InterruptedExceptionExample {    private ExecutorService executorService = Executors.newSingleThreadExecutor();
    public void handleWithTimeout() throws InterruptedException {        Future<?> future = executorService.submit(() -> {            try {                // sleep 模拟处理逻辑                Thread.sleep(1000);            } catch (InterruptedException e) {                System.out.println("interrupted");            }            System.out.println("continue task");            // 异常被忽略, 继续处理        });        // 等待任务结果, 如果超过 500ms 则中断        Thread.sleep(500);        if (!future.isDone()) {            System.out.println("cancel");            future.cancel(true);        }    }}
  • 避免 catch Error

不要吞并 Error,Error 设计本身就是区别于异常,一般不应该被 catch,更不能被吞掉。举个例子,OOM 有可能发生在任意代码位置,如果吞并 Error,让程序继续运行,那么以下代码的 start 和 end 就无法保证一致性。​​​​​​​

public class ErrorExample {
    private Date start;
    private Date end;
    public synchronized void update(long start, long end) {        if (start > end) {            throw new IllegalArgumentException("start after end");        }        this.start = new Date(start);        // 如果 new Date(end) 发生 OOM, start 有可能大于 end        this.end = new Date(end);    }}

Spring Bean 隐式依赖

  • 反例 1: SpringContext 作为静态变量

UserController 和 SpringContextUtils 类没有依赖关系, SpringContextUtils.getApplication() 可能返回空。并且 Spring 非依赖关系的 Bean 之间的初始化顺序是不确定的,虽然可能当前初始化顺序恰好符合期望,但后续可能发生变化。​​​​​​​

@Componentpublic class SpringContextUtils {
    @Getter    private static ApplicationContext applicationContext;
    public SpringContextUtils(ApplicationContext context) {        applicationContext = context;    }}
@Componentpublic class UserController {
    public void handle(){        MyService bean = SpringContextUtils.getApplicationContext().getBean(MyService.class);    }}

反例 2: Switch 在 Spring Bean 中注册, 但通过静态方式读取​​​​​​​

@Componentpublic class SwitchConfig {
    @PostConstruct    public void init() {        SwitchManager.register("appName", MySwitch.class);    }
    public static class MySwitch {        @AppSwitch(des = "config", level = Switch.Level.p1)        public static String config;    }}
@Componentpublic class UserController{
    public String getConfig(){        // UserController 和 SwitchConfig 类没有依赖关系, MySwitch.config 可能还没有初始化        return MySwitch.config;    }}
通过 SpringBeanFactory 保证初始化顺序:​​​​​​​
public class PreInitializer implements BeanFactoryPostProcessor, PriorityOrdered {

  @Override
  public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE;
  }

  @Override
  public void postProcessBeanFactory(
    ConfigurableListableBeanFactory beanFactory) throws BeansException {
       try {
        SwitchManager.init(应用名, 开关类.class);
      } catch (SwitchCenterException e) {
        // 此处抛错最好阻断程序启动,避免开关读不到持久值引发问题
    } catch (SwitchCenterError e) {
        System.exit(1);
    }
    }
}
@Component
public class SpringContextUtilPostProcessor implements BeanFactoryPostProcessor, PriorityOrdered, ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        SpringContextUtils.setApplicationContext(applicationContext);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

内存/资源泄漏

虽然 JVM 有垃圾回收机制,但并不意味着内存泄漏问题不存在,一般内存泄漏发生在在长时间持对象无法释放的场景,比如静态集合,内存中的缓存数据,运行时类生成技术等。

  • LoadingCache 代替全局 Map
@Servicepublic class MetaInfoManager {
    // 对于少量的元数据来说, 放到内存中似乎并无大碍, 但如果后续元数据量增大, 则大量对象则内存中无法释放, 导致内存泄漏    private Map<String, MetaInfo> cache = new HashMap<>();
    public MetaInfo getMetaInfo(String id) {        return cache.computeIfAbsent(id, k -> loadFromRemote(id));    }
    private LoadingCache<String, MetaInfo> loadingCache = CacheBuilder.newBuilder()        // loadingCache 设置最大 size 或者过期时间, 能够限制缓存条目的数量        .maximumSize(1000)        .build(new CacheLoader<String, MetaInfo>() {            @Override            public MetaInfo load(String key) throws Exception {                return loadFromRemote(key);            }        });
    public MetaInfo getMetaInfoFromLoadingCache(String id) {        return loadingCache.getUnchecked(id);    }
    private MetaInfo loadFromRemote(String id) {        return null;    }
    @Data    public static class MetaInfo {        private String id;        private String name;    }}
  • 谨慎使用运行时类生成技术

Cglib, Javasisit 或者 Groovy 脚本会在运行时创建临时类, Jvm 对于类的回收条件十分苛刻, 所以这些临时类在很长一段时间都不会回收, 直到触发 FullGC.

  • 使用 Try With Resource

使用 Java 8 try wiht Resource 语法:​​​​​​​

public class TryWithResourceExample {
    public static void main(String[] args) throws IOException {        try (InputStream in = Files.newInputStream(Paths.get(""))) {            // read        }    }}

性能问题

URL 的 hashCodeeuqals 方法

URL 的 hashCode,equals 方法的实现涉及到了对域名 ip 地址解析,所以在显示调用或者放到 Map 这样的数据结构中,有可能触发远程调用。用 URI 代替 URL 则可以避免这个问题。

反例 1:​​​​​​​

public class URLExample {    public void handle(URL a, URL b) {        if (Objects.equals(a, b)) {
        }    }}

反例 2:​​​​​​​

public class URLMapExample {
    private static final Map<URL, Object> urlObjectMap = new HashMap<>();
}

循环远程调用:​​​​​​​

public class HSFLoopInvokeExample {
    @HSFConsumer    private UserService userService;
    public List<User> batchQuery(List<String> ids){        // 使用批量接口或者限制批量大小       return ids.stream()            .map(userService::getUser)            .collect(Collectors.toList());    }}
  • 了解常见性能指标&瓶颈

了解一些基础性能指标,有助于我们准确评估当前问题的性能瓶颈,这里推荐看一下《每个程序员都应该知道的延迟数字》。比如将字段设置为 volatile,相当于每次都需要读主存,读主存性能大概在纳秒级别,在一次 HSF 调用中不太可能成为性能瓶颈。反射相比普通操作多几次内存读取,一般认为性能较差,但是同理在一次 HSF 调用中也不太可能成为性能瓶颈。

图片

在服务端开发中, 性能瓶颈一般集中在:

大量日志打印

大对象序列化

网络调用: 比如 HSF, HTTP 等远程调用

数据库操作

  • 使用专业性能测试工具估性能

不要尝试自己实现一个简陋的性能测试,在测试代码运行过程中,编译器,JVM, 操作系统各个层级上都有可能存在你意料之外的优化,导致测试结果过于乐观。建议使用 jmh,arthas 火焰图,这样的专业工具做性能测试。

反例:​​​​​​​

public class ManualPerformanceTest {
    public void testPerformance() {        long start = System.currentTimeMillis();        for (int i = 0; i < 1000; i++) {            // 这里 mutiply 没有任何副作用, 有可能被优化之后被干掉            mutiply(10, 10);        }        System.out.println("avg rt: " + (System.currentTimeMillis() - start) / 1000);    }
    private int mutiply(int a, int b) {        return a * b;    }}

正例:

使用火焰图

图片

正例 2 :

使用 jmh 评估性能​​​​​​​

@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)@Fork(3)@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.NANOSECONDS)public class JMHExample {
    @Benchmark    public void testPerformance(Blackhole bh) {        bh.consume(mutiply(10, 10));    }
    private int mutiply(int a, int b) {        return a * b;    }}

Spring 事务问题

  • 注意事务注解失效的场景

当打上 @Transactional 注解的 spring bean 被注入时,spring 会用事务代理过的对象代替原对象注入。

但是如果注解方法被同一个对象中的另一个方法里面调用,则该调用无法被 Spring 干预,自然事务注解也就失效了。​​​​​​​

@Componentpublic class TransactionNotWork {
    public void doTheThing() {        actuallyDoTheThing();    }
    @Transactional    public void actuallyDoTheThing() {    }}

参考资料:

  1. Null:价值 10 亿美元的错误: https://www.infoq.cn/article/uyyos0vgetwcgmo1ph07

  2. 双重检查锁失效声明: https://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

  3. 每个程序员都应该知道的延迟数字: https://colin-scott.github.io/personal_website/research/interactive_latency.html

基于STM32与毫米波雷达的非接触式睡眠监测系统 物联网和嵌入式系统技术正在推动医疗健康设备的智能化发展。通过传感器网络采集生理信号,结合信号处理算法实现健康监测已成为主流技术方案。毫米波雷达凭借其非接触检测特性,在呼吸、心率等生命体征监测中展现出独特优势。STM32系列MCU凭借丰富外设和低功耗特性,成为医疗级嵌入式设备的首选平台。本系统整合60GHz毫米波雷达、红外测温与无线传输模块,构建了完整的睡眠质量评估解决方案,其硬件架构设计、信号处理算法和低功耗优化策略对可穿戴医疗设备开发具有参考价值。 阅读详情

相关推荐

VSCode终端打不开?3分钟搞定Windows下Terminal配置(附最新JSON设置方法)

本文针对Windows系统下VSCode终端无法启动的常见问题,提供了详细的诊断与解决方案。核心在于更新已弃用的旧配置,采用最新的JSON设置方法,通过定义`terminal.integrated.profiles.windows`和指定`terminal.integrated.defaultProfile.windows`,快速修复并优化终端配置,实现三分钟内恢复正常使用。

flower的专栏 744

Java编程常见bug及解决方法

本文介绍了几种常见的Java编程bug,包括逻辑错误、空指针异常、数组越界异常和类型转换异常,同时也提供了相应的解决方法。此外,在多线程编程时,还需要注意并发问题,使用同步机制来保证共享资源的正确性。读者可以通过本文了解这些常见bug的出现原因和解决方法,避免在编写Java程序时出现这些问题。

weixin_43653660的博客 2133

5.4 磁悬浮轴承控制系统仿真:在MATLAB/Simulink中搭建包含功放、传感器模型的闭环系统模型,进行稳定性与动态性能仿真

磁悬浮轴承控制系统仿真方法 摘要:磁悬浮轴承控制系统仿真需建立包含转子动力学、传感器、控制器、功率放大器和电磁执行器的高保真非线性模型。通过MATLAB/Simulink搭建闭环系统,重点建模传感器带宽限制与噪声、功放饱和特性以及电磁力非线性。仿真分析包括时域阶跃响应、扰动抑制测试,频域稳定性分析(伯德图、奈奎斯特图),以及参数摄动下的鲁棒性验证。关键要验证控制算法在非线性因素影响下的稳定性和动态性能,为实际系统实现提供可靠依据。仿真中需特别注意物理量单位一致性和数字控制离散化效应。

技术工作者 1108

Java100例常见错误及解决方案

另外,文件的读取(FileInputStream,FileChannel,FileDescriptor,File)没法指定超时时间,而且 IO 操作均涉及到本地方法调用,这个更操作了 JVM 的控制范围,在分布式文件系统中,对 IO 的操作内部实际上是网络调用。Rollableinterface 里的 ball 是 publicstaticfinal 的,final 的 object 是不能被改变 reference 的。这是 EJB3 的一个查询操作,可能出现异常的原因是:结果不唯一;

qq_41365496的博客 4394

国内网络环境下Calico v3.26.4安装避坑指南(附华为云镜像加速脚本)

本文为国内开发者提供Calico v3.26.4的高效部署指南,重点介绍如何通过华为云镜像加速服务解决Kubernetes集群网络插件镜像拉取问题。文章包含详细的镜像加速脚本、部署清单修改方法及深度排错技巧,帮助开发者快速完成Calico网络插件的安装与配置。

brown的博客 291

【OpenClaw从入门到精通】第24篇:OpenClaw Skill商业化实战指南——从0开发付费技能,在ClawHub变现(2026实测版)

本文聚焦OpenClaw Skill商业化的全流程落地,基于2026年生态现状、公开行业报告及开发者指南,拆解付费Skill的市场机会、商业模式、技术实现、发布运营及避坑要点。核心围绕“Freemium API Backend”主流路径,通过虚拟但贴合真实场景的“金融研报复现”案例,提供从需求分析、定价设计到代码开发、ClawHub上架的完整实操方案。文中包含可直接复用的代码片段、执行结果演示及流程图解,既满足新手快速入门的需求,也为进阶开发者提供商业化落地的关键思路,帮助读者抓住AI Agent早期红利。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1091

Bug总结 - Java遇到的问题与解决方案总集篇

Bug总结 - Java遇到的问题与解决方案总集篇

qq_39123467的博客 5126

从苏宁电器到卡巴斯基第02篇:我的本科时光(中)

怎么还分班了呢? 大概是在大二第二学期的时候吧,学院突然通知我们要分班。因为我们目前所有学生都是属于工商管理专业的,而从下个学期开始,就要分为会计、市场营销以及工商管理这三个方向。这还真是打了我一个措手不及,我都不知道还有分班这一回事。不过也没关系,我继续选择我的工商管理就好了。不过,在实际的选择结果上,像会计和工商管理这种学科,选的人自然是占了绝大多数,而选择市场营销的,大概也就是十

Gleam的专栏 9608

[ 代码审计篇 ] Java 代码审计常用漏洞总结

主要代码审计方法是跟踪用户输入数据和敏感函数参数回溯:跟踪用户的输入数据, 判断数据进入的每一个代码逻辑是否有可利用的点, 此处的代码逻辑可以是一个函数,或者是条小小的条件判断语句。敏感函数参数回溯, 根据敏感函数, 逆向追踪参数传递的过程。这个方法是最高效, 最常用 的方法。大多数漏洞的产生是因为函数的使用不当导致的, 只要找到这些函数, 就能够快速 挖掘想要的漏洞。以下是基于关键词审计技巧总结:在搜索时要注意是否为整个单词, 以及小写敏感这些设置。

qq_51577576的博客 1393

UDF学习(四)FLUENT UDF-DEFINE_PROFILE宏

利用DEFINE_PROFLILE可以指定以下边界或计算域信息:DEFINE_PROFILE(name,t,i)//既可以用。

weixin_44386973的博客 1807

基于Simulink的电机热阻模型建立与仿真

本文详细介绍了基于Simulink的电机热阻模型建立方法。通过将电机传热路径分解为5段关键热阻(绕组内部、槽绝缘、铁芯、机壳、冷却系统),采用Simscape Thermal模块构建热阻网络模型。重点阐述了参数化热阻计算、实验数据校准、不同设计方案对比等关键步骤,并以15kW车用PMSM为例演示建模过程。文章还分享了非线性热阻处理、多维网络构建等高级技巧,指出该模型在热设计迭代、散热匹配、故障诊断等方面的重要工程价值,为电机热安全设计提供了有效的数字化解决方案。

xiaoheshang_123的博客 337

Java开发中常见错误及解决方案大全

掌握并解决这些常见的Java错误,将极大地提高你的开发效率和代码质量。希望这篇文章能帮助你在实际开发中避免常见陷阱,写出更加稳健和高效的Java代码。如果你喜欢这篇文章,请分享给更多的Java开发者,并关注我们的Java栏目,获取更多精彩内容和最新资讯!你的支持是我们前进的最大动力!

阿里渣渣java研发组-群主 4273

74、刀具磨损监测与寿命预测分析

本文综述了刀具磨损监测与寿命预测的研究现状,分析了力信号、功率信号、振动信号和声发射信号在刀具状态监测中的应用及其优缺点。介绍了当前常用的刀具寿命模型及故障诊断流程,并总结了基于不同信号的监测方法。文章指出,尽管已有多种方法在理论上取得进展,但在实际应用中仍面临挑战。未来研究方向包括采用更先进的神经网络、深入探索多信号融合技术以及有效利用工业大数据,以提升刀具状态识别的准确性与可靠性。

lstm7chronicler的博客 277

C语言的几种缺陷及其规避方法

异常处理机制:C语言中没有自带的异常处理机制,但是可以通过设置错误码来表示异常情况,极其简单,也可以在C语言中使用一些异常处理库如setjmp.h、siglongjmp.h等来实现类似的机制。总之,虽然C语言是一种高效的编程语言,在工业界和学术界都得到了广泛的应用,但其存在的这些缺点也限制了其进一步的发展,使得在现代编程环境下,需要我们更加注意这些缺点,并采取相应的预防措施。容易出现内存管理问题:C语言中,程序员需要手动管理内存,包括内存的分配和释放,容易出现内存泄漏、越界等问题。

嵌入式之斋 1873

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

缺陷 & 规避

Checked Exception 是在编译期要求必须处理的异常,也就是非 RuntimeException 类型的异常,但 Java Checked 的异常给接口的调用者造成了一定的负担,导致异常声明层层传递,如果顶层能够处理该异常,我们可以通过 lombok 的 @SneakyThrows 注解规避 Checked exception。虽然 JVM 有垃圾回收机制,但并不意味着内存泄漏问题不存在,一般内存泄漏发生在在长时间持对象无法释放的场景,比如静态集合,内存中的缓存数据,运行时类生成技术等。

m0_62986746的博客 905

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Java编程中常见的逻辑陷阱与规避策略

采用Java 8引入的`java.time`包(如`LocalDate`、`ZonedDateTime`)。陷阱:使用旧的`Date`和`Calendar`类处理日期时间,存在线程安全和使用复杂的问题。陷阱:使用`float`或`double`进行精确计算时,可能因精度丢失导致结果不符合预期。- 对于需要高精度的计算(如金融领域),使用`BigDecimal`类。- 采用并发安全的集合类(如`ConcurrentHashMap`)。- 使用`synchronized`关键字或`Lock`实现同步。

zUnRlcUx的博客 385

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

如何使用AI进行自动代码审查与缺陷检测

借助大语言模型(LLM)、深度学习(Deep Learning)、自然语言处理(NLP)等技术,AI不仅能高效识别代码缺陷,还能理解代码意图、推荐最佳实践,甚至预测潜在漏洞,从而提升代码质量并降低软件故障风险。未来,AI不仅能发现代码缺陷,还能理解代码逻辑、提供优化建议,甚至主动修复问题。对于开发者而言,拥抱AI驱动的代码审查,将成为提升代码质量、加速交付的关键武器!传统静态分析工具基于固定规则,而AI则利用机器学习模型,通过大量代码数据进行训练,从而自动学习模式,检测缺陷。用ChatGPT做软件测试。

测试者家园 3856

Java编程中的常见陷阱与规避策略

陷阱:重写`equals`方法但未重写`hashCode`,导致在基于哈希的集合(如`HashMap`)中行为异常。- 使用Java 8引入的`java.time`包(如`LocalDate`、`ZonedDateTime`)。陷阱:将可变对象(如`Date`、`ArrayList`)作为不可变对象使用,可能导致意外修改。陷阱:使用`float`或`double`进行精确计算(如货币运算)时,可能产生精度误差。- 使用`Math`类的方法(如`addExact`)进行运算,溢出时抛出异常。

EGNdlBRT的博客 306

新手必藏!修复代码缺陷避坑手册,从入门到精通

首先是利用调试工具,大多数集成开发环境(IDE)都自带调试功能,比如 Eclipse 的断点调试,在怀疑有问题的代码行设置断点,运行程序后,程序会在断点处暂停,此时可以查看变量的值、程序执行流程,逐步排查问题。其次,要保证代码的可读性和可维护性,修复后的代码要符合编码规范,添加必要的注释,说明修复的原因和思路。例如,编写一个计算加法的函数,对应的单元测试要测试正常的整数加法、小数加法、负数加法等情况,当修改函数逻辑后,运行单元测试,若测试通过,则说明函数功能正常;修改后的代码如下:​。

2503_92604243的博客 542

Java开发中常见的十大陷阱与规避策略

为避免NPE,应在使用对象前进行非空校验,或使用Java 8引入的Optional类来优雅地处理可能为null的情况。重写equals方法时必须同时重写hashCode方法,以保证两个相等的对象具有相同的哈希码,否则在使用HashSet、HashMap等基于哈希的集合时会出现不可预知的行为。推荐使用Java 8引入的java.time包中的新日期时间API(如LocalDate、LocalDateTime),它们是不可变的且线程安全,提供了更清晰和更强大的日期时间操作功能。

gao_gavin_fei的博客 380

修复代码缺陷实战教程:手把手教你搞定常见 bug

同时,分享代码审查、单元测试等提前规避 bug 的方法,帮助开发者建立系统化的 bug 排查思维,提升代码质量与问题解决效率,适用于初、中级开发者及需要优化代码调试流程的技术人员。本文通过实战案例,详细讲解了语法错误、逻辑漏洞、数据类型异常、内存泄漏四种常见 bug 的修复流程,同时介绍了 IDE 调试、日志、性能监控等工具的使用技巧,核心要点可总结为以下三点:​。掌握合适的工具能大幅提升 bug 排查效率,不同场景下需使用不同的调试工具,以下介绍常用工具及使用技巧:​。// 无论是否报错,都释放连接​。

2503_92848840的博客 1589

JavaSinkTracer:自研Java代码审计工具

JavaSinkTracer 是基于 Python javalang 库开发的一款轻量级 Java 源代码漏洞审计工具,开发人员 Tr0e。

道阻且长,行则将至 2563
上一篇: 2024 年了,Facebook、Google 竟然都不用 Git 管理代码?
下一篇: 无痕模式是脱裤子放屁?谷歌差点赔了 50 亿。。。
IT界那些事儿
博客等级 码龄6年 2万+粉丝 22原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值