发表于 | 分类于

哈喽，大家好，我是了不起。

爬虫，也被称为网络爬虫或网络蜘蛛，是一种自动化的网络机器人，其主要功能是按照一定的规则，自动浏览互联网并从网页中提取信息。

作为一个开发人员，相信大家都尝试过写一些爬虫，合理的利用一些爬虫工具，对于我们一些还是挺有帮助的。

比如自动化测试，使用爬虫技术对网站进行自动化测试，检查链接是否有效，确保网站内容的正确显示。

今天就给大家介绍一款开源的爬虫工具，不用写代码即可完成爬虫。

阅读全文 »

发表于 | 分类于

在数字化高速发展的今天，确保在线服务的可靠性和可用性变得比以往任何时候都重要。这就需要一款强大的监控工具，以确保你的服务器、网站和API始终在线。

在众多监控工具中，Uptime Kuma作为一款开源、现代化的服务监控解决方案，正逐渐成为众多开发者和系统管理员的心头好。

本文将为您详细介绍Uptime Kuma的作用、特性以及如何轻松安装并使用它来守护您的在线业务。

Uptime Kuma的作用

Uptime Kuma是一个开源监控工具，它允许你监控你的服务，并确保你是第一个知道它们何时下线的人。与传统的SaaS监控服务（如UptimeRobot）不同，Uptime Kuma提供了一个可完全控制和定制的环境。

它有以下主要特点：

  • 多种监控类型：它可以监控HTTP/S、TCP、HTTP(s) Keyword、Ping、DNS Record、Steam Game Server等。
  • 灵活的告警策略：当监控到的服务状态发生变化时，Uptime Kuma可以通过多种通知渠道，如Telegram、Discord、Slack、Email等提醒你。
  • 界面友好的仪表板：清晰直观地展示所有监控项目的当前状态、历史记录及响应时间统计，帮助您一目了然地掌握服务健康状况。
  • 高度可定制化： 支持自定义脚本监控、多语言界面以及丰富的主题选择，满足不同用户的个性化需求。
  • 开源免费： 作为开源软件，Uptime Kuma不仅免费使用，还允许用户根据自身需求进行二次开发和功能扩展。

安装方式

Docker（推荐）

Uptime Kuma提供了多种安装选项，以适应不同的用户需求。可以通过Docker容器快速安装，也可以从源代码构建。这里基本演示Docker的安装方法：

首先确保服务器已经安装了Docker: 如果你还没有Docker，首先需要安装它。根据你的操作系统，你可以从Docker官网下载合适的安装包。

  1. 拉取Uptime Kuma镜像: 使用以下命令从Docker Hub上拉取最新的Uptime Kuma镜像。
1
docker pull louislam/uptime-kuma
  1. 启动Uptime Kuma容器: 使用以下命令启动一个Uptime Kuma实例。
1
docker run -d --name uptime-kuma -p 3001:3001  -v ./uptime-kuma-data:/app/data louislam/uptime-kuma

上面的命令会创建一个新的Uptime Kuma容器，名为uptime-kuma，并且将容器的3001端口映射到主机的3001端口。

  1. 访问Uptime Kuma: 在你的浏览器中访问http://localhost:，你将看到Uptime Kuma的登录页面，按照初次启动向导完成安装过程。

Docker Compose（推荐）

1
2
3
4
5
6
7
8
9
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1.23.13
    container_name: uptime-kuma
    restart: always
    volumes:
      - ./data:/app/data
    ports:
      - 3001:3001

编写docker-compose.yaml文件，用docker compose up -d 启动即可。

初始化和配置和上述一致。

进一步的配置和定制教程可以在Uptime Kuma的GitHub文档中找到，包括如何添加监控项、配置通知方式等。

小结

Uptime Kuma是一个功能强大且易于使用的监控工具，它是为希望完全控制监控过程的团队和个人设计的。

它的自托管特性意味着没有外部依赖，你数据的隐私性和安全性得到了保证。

除此之外，它开源且完全免费，适合希望有成本效益解决方案的企业和开发者。如果你正在寻找一个灵活而且强大的监控工具，Uptime Kuma无疑是一个值得考虑的选择。

阅读全文 »

发表于 | 分类于

Java 8 引入了强大的 Stream API，为处理集合数据提供了简洁、高效的解决方案。 其中，parallel() 方法为流处理引入了并行化能力，允许开发者充分利用多核处理器的优势，大幅提升大规模数据集的处理效率。

本篇文章将带你开启并行流处理之旅，认识 Java 8 Stream API 中的 parallel()。

什么是 parallel()

parallel() 是 Java 8 Stream API 中的一个方法，用于将一个顺序流转换为并行流。并行流是一种可以同时在多个线程上执行操作的流，它将流的元素分割成多个子集，每个子集在不同的线程上独立处理，最后将结果合并。使用 parallel() 方法可以轻松开启并行流处理模式，无需显式管理线程和同步。

1
2
3
4
5
6
7
List<Integer> numbers = ...; // 假设有一个包含大量元素的列表

numbers.stream() // 创建顺序流
    .parallel() // 转换为并行流
    .filter(n -> n % 2 == 0) // 并行过滤偶数
    .map(n -> n * 2) // 并行映射为原数的两倍
    .forEach(System.out::println); // 并行打印结果

在这个示例中，parallel() 方法将顺序流转换为并行流，后续的 filter()、map() 和 forEach() 操作将在多个线程上并行执行，从而加速数据处理。

并行流的工作原理

并行流处理背后的核心机制主要包括以下几个方面：

  1. 分割与合并
  2. 自动流水线化
  3. 适应性执行策略

并行流根据数据集的大小、处理器核心数等因素动态调整并行度和任务划分策略。对于小规模数据集或不适合并行化的操作，Java 8 会自动退化为顺序流处理，避免不必要的线程开销。

总之，parallel() 方法通过将原始列表拆分成多个子任务，并在独立线程上并行执行流操作链的各个阶段，最后合并处理结果，实现了对列表数据的高效并行处理。 具体的拆分策略和并行执行细节由 JVM 自动管理，开发者无需关心底层实现，只需关注流式编程的高层抽象。

实战应用

适合parallel()并行流的应用场景有：

  1. 大规模数据集处理
  2. CPU 密集型操作
  3. 可并行化的中间操作，如 filter()、map()、flatMap()、sorted()等。

示例1：大规模数据集处理

场景：在一个数据分析项目中，需要对一个包含百万条记录的数据集进行复杂过滤和计算。使用并行流可以显著加快处理速度，充分利用多核处理器资源。 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class ParallelDataProcessingExample {
    public static void main(String[] args) {
        List<DataRecord> records = generateLargeDataRecords(); // 假设生成包含百万条记录的数据集

        List<DataRecord> filteredAndProcessedRecords = records.parallelStream()
                .filter(record -> record.isValid()) // 并行过滤有效记录
                .map(record -> record.computeComplexMetric()) // 并行计算复杂度量
                .collect(Collectors.toList());

        // ... 使用 filteredAndProcessedRecords 进行后续分析 ...
    }

}

public class DataRecord {
    // ... 数据记录的字段、方法等 ...

    public boolean isValid() {
        // ... 判断记录是否有效的逻辑 ...
    }

    public DataRecord computeComplexMetric() {
        // ... 计算复杂度量的逻辑 ...
    }
}

示例2

场景： 假设有一个电商系统需要批量更新大量商品的价格，每个商品的更新过程涉及网络请求到不同服务获取最新价格信息，然后保存到数据库。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Service
@RequiredArgsConstructor
public class ProductService {

    private final PriceService priceService;
    private final ProductRepository productRepository;
    private final Executor asyncExecutor;


    /**
	 * 批量更新商品价格
	 *
	 * @param productIds 商品ID列表
	 */
	public void batchUpdatePrices(List<Integer> productIds) {
		CompletableFuture<Void> allDbUpdates = CompletableFuture.allOf(productIds.stream()
				.parallel()
				.map(productId -> CompletableFuture.supplyAsync(() -> priceService.getLatestPrice(productId), asyncExecutor)
						.thenAcceptAsync(newPrice -> productRepository.updatePrice(productId, newPrice), asyncExecutor))
				.toArray(CompletableFuture[]::new));

		// 等待所有数据库更新完成
		allDbUpdates.join();
	}
}

在这个示例中：

  • 首先，我们创建了一个包含100个商品ID的列表，并对其应用了 parallel() 流操作，使得后续的 map() 操作能并行执行。
  • 为每个商品ID创建一个 CompletableFuture，通过 supplyAsync() 异步调用 PriceService 获取最新价格。
  • 进一步使用 thenAcceptAsync() 异步操作。在获取到最新价格之后更新数据库。
  • 最终，使用 CompletableFuture.allOf() 等待所有数据库更新操作完成。

小结

Java 8 Stream API 中的 parallel() 方法为处理集合数据提供了便捷的并行化途径。 在复杂的异步处理场景中，可以结合 CompletableFuture 与并行流，进一步提升程序的并发性和响应能力。 通过合理使用并行流，开发者可以显著提升大规模数据集处理的性能，充分发挥现代多核处理器的潜力。 然而，使用并行流时也应注意避免数据依赖、状态共享等问题，适时进行性能评估与调整。

阅读全文 »

发表于 | 分类于

哈喽，大家好，MySQL作为广泛使用的开源关系型数据库管理系统，应该没有Java开发没使用过吧。

关于MySQL，我们大部分时间都在聊，如何提高查询效率，今天我们来聊聊如何提高MySQL的插入效率。

提高插入效率的方式

一般情况下，数据库是运行在专门的服务器上，提高插入效率最明显的当然是提高服务器配置啦。 比如，使用高性能的CPU和SSD磁盘，使用分布式系统架构，将写入压力分散到多个节点。 这个方式的成本也是最高的，老板们当然不会使用这种方式了。

我们还可以从其他方面入手：

  1. 调整数据库配置：优化缓冲池大小、增大批量插入缓冲区等，通过调整MySQL数据库参数的方式。
  2. 选择使用MyISAM存储引擎，因为其简单的表锁机制和无事务开销而在插入速度上表现更优。
  3. 使用批量插入的方式。

考虑到实际的应用场景，我们最可能操作的就是使用第3种实现方式，通过批量插入的方式来提高效率。

探索批量插入

常用的批量插入的方式有2种：

  1. 拼接SQL，使用 insert into xxx (...) values (...),(...),(...)
  2. 利用事务，将批量插入操作封装在单个事务中，可以减少事务开销并提高并发性能。
    1. 在mybatisPlus，以及mybatis-flex中，saveBatch 就是使用的这种方式

接下来我们来测试一下这几个方法。

测试代码

测试的SQL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
CREATE TABLE `orders`  
(  
    `order_id`         BIGINT         NOT NULL AUTO_INCREMENT COMMENT '订单ID（主键）',  
    `customer_id`      BIGINT         NOT NULL COMMENT '客户ID（关联customer表）',  
    `order_status`     tinyint(4)     NOT NULL DEFAULT 1 COMMENT '订单状态 1-待支付 2-已支付 3-待发货 4-已发货 5-已完成 6-已取消',  
    `payment_method`   tinyint(4)     NULL     DEFAULT null COMMENT '支付方式; 1-现金 2-支付宝 3-微信 4-银行卡',  
    `total_amount`     DECIMAL(10, 2) NOT NULL COMMENT '订单总金额',  
    `shipping_fee`     DECIMAL(10, 2) NOT NULL DEFAULT 0 COMMENT '运费',  
    `coupon_discount`  DECIMAL(10, 2) NOT NULL DEFAULT 0 COMMENT '优惠券减免金额',  
    `order_date`       DATETIME       NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '下单日期',  
    `payment_time`     DATETIME                DEFAULT NULL COMMENT '支付时间',  
    `shipping_address` VARCHAR(255)   NULL COMMENT '收货地址',  
    `receiver_name`    VARCHAR(50)    NULL COMMENT '收货人姓名',  
    `receiver_phone`   VARCHAR(20)    NULL COMMENT '收货人电话',  
    PRIMARY KEY (`order_id`)  
) ENGINE = InnoDB  
  DEFAULT CHARSET = utf8mb4 COMMENT ='订单信息表';

一、使用 batchXml

1
2
3
4
5
insert into orders (order_id, customer_id, order_status, payment_method, order_date, total_amount, shipping_fee, coupon_discount)  
values  
<foreach collection="orders" item="item" separator=",">  
    (#{item.orderId}, #{item.customerId}, #{item.orderStatus}, #{item.paymentMethod}, #{item.orderDate}, #{item.totalAmount}, #{item.shippingFee}, #{item.couponDiscount})  
</foreach>

二、使用mybatis-flex提供的saveBatch

1
ordersService.saveBatch(list);

三、手动控制事务的提交，saveBatchSession

1
2
3
4
5
6
7
8
9
10
public void saveBatchSession(List<Orders> orders) {  
    SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);  
    OrdersMapper mapper = session.getMapper(OrdersMapper.class);  
    for (int i = 0,length = orders.size(); i < length; i++) {  
        mapper.insert(orders.get(i));  
    }  
    session.commit();  
    session.clearCache();  
    session.close();  
}

启动代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Test  
public void generatorTestData() {  
	genOrders(0L, 100000L);  
}

private void genOrders(long start, long end) {  
	List<Orders> list = new ArrayList<>();  
	long s = System.currentTimeMillis();  
	for (long i = start + 1; i <= end; i++) {  
		if ((i - start) % 1000 == 0) {  
			ordersService.saveBatchSession(list);  
//          ordersService.saveBatchXml(list);   
//			ordersService.saveBatch(list);  
			list.clear();  
			itemAll.clear();  
			System.out.println("生成数据：" + (i - start) + "条，耗时：" + (System.currentTimeMillis() - s) + "ms");  
			s = System.currentTimeMillis();  
			continue;  
		}  
		// 构建所有属性  
		list.add(Orders.builder() ... .build());
	}  
	ordersService.saveBatch(list);  
}

测试结果

使用了3种方式进行测试

未开启批处理，batchXml image.png

未开启批处理，mybatis-flex提供的saveBatch image.png

未开启批处理，saveBatchSession

image.png

从这里的结果可以看出，使用 batchXml 的效率是最高的，远远超越其他方式。 但是仔细一想，这些数据应该很不正常，插入1000条数据，竟然需要4秒左右，和单条插入1000次的时间几乎没有区别。

开启批处理

经过一番查询资料，并检查配置，发现果然另有玄机，连接数据库的时候没有开启批处理

开启方式：在spring的配置文件中，连接数据源时，url需要增加 allowPublicKeyRetrieval=true

然后重新测试一遍。

开启批处理，saveBatchXml image.png

开启批处理，mybatis-flex提供的saveBatch image.png

开启批处理，saveBatchSession image.png

这次的结果就比较正常了，可以看出来:

  • saveBatchSession最快
  • mybatis-flex提供的saveBatch 因为有些额外的操作，多消耗了10ms左右的时间
  • saveBatchXml 相较于另外两种方式，慢了30ms~40ms。

接下来，把每批次的处理数据由1000次增加到10000次，再次进行测试。

开启批处理，saveBatchXml，10000条一批次 image.png

开启批处理，saveBatchSession，10000条一批次 image.png

开启批处理，mybatis-flex提供的saveBatch，10000条一批次 image.png

由此结果可以看出来：

  • saveBatchSession和mybatis-flex提供的saveBatch 耗时基本一致
  • saveBatchXml就明显的慢一些，按照效率差算，差了将近50%的效率 \(\text { 效率差 }=\frac{\text { 较长时间 }- \text { 较短时间 }}{\text { 较短时间 }}=\frac{1200 \mathrm{~ms}-800 \mathrm{~ms}}{800 \mathrm{~ms}}\)

总结

综上，提高MySQL插入效率主要可通过调整数据库配置、选择适合的存储引擎以及运用批量插入策略等方式实现。 在实际应用中，尤其是在使用ORM框架进行数据操作时，应合理选择并充分利用批量插入功能，以最大程度提升插入效率。

省流

  1. 连接数据时，数据源配置文件url加上 allowPublicKeyRetrieval=true
  2. 数据量很大时，使用mybatisPlus或MybatisFlex提供的 saveBatch即可。
阅读全文 »

发表于 | 分类于

在现代软件开发中，异步编程已成为提升系统性能、响应能力和可扩展性的关键手段。Java 8 引入了 CompletableFuture 类，为 Java 平台带来了强大的异步编程能力。

本篇文章将带你认识这个异步编程神器：CompletableFuture。

什么是 CompletableFuture

CompletableFuture 是 Java 8 引入的 java.util.concurrent 包下的一个类，它代表一个异步计算的结果，可以是已完成、正在进行或尚未开始。 CompletableFuture 提供了一种灵活、类型安全的方式来表达异步操作的生命周期，包括创建、组合、处理结果以及处理异常。其设计灵感来源于函数式编程中的 Promises/Futures 模式，旨在简化异步编程模型，提高代码的可读性和可维护性。

CompletableFuture 的核心功能

1. 创建 CompletableFuture

a. completedFuture(T value)

completedFuture(T value) 是一个静态工厂方法，用于创建一个已经处于完成状态且包含给定结果值的 CompletableFuture。这适用于预先计算好的结果或常量值，使得其他组件可以以异步形式消费。

b. supplyAsync(Supplier<U> supplier, Executor executor)

supplyAsync() 方法接受一个 Supplier 函数和一个可选的 Executor，异步执行 supplier.get()，并将结果封装到一个新的 CompletableFuture 中。计算在 Executor 管理的线程中进行，不阻塞当前线程。

c. runAsync(Runnable runnable, Executor executor)

类似于 supplyAsync()，runAsync() 接受一个 Runnable 任务和一个 Executor，异步执行任务。由于 Runnable 没有返回值，runAsync() 返回的 CompletableFuture 完成时没有结果。

2. 组合 CompletableFuture

a. thenApply(Function<? super T,? extends U> fn)

在当前 CompletableFuture 完成后，应用给定的 Function 处理结果，并返回一个新的 CompletableFuture，其结果为 Function 应用后的值。

b. thenAccept(Consumer<? super T> action)

当当前 CompletableFuture 完成后，执行给定的 Consumer 消费结果。由于 Consumer 没有返回值，返回的 CompletableFuture 完成时没有结果。

c. thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)

当当前 CompletableFuture 与另一个 CompletionStage（如另一个 CompletableFuture）都完成时，应用给定的 BiFunction 合并两个结果，并返回一个新的 CompletableFuture。

3. 异常处理

a. exceptionally(Function<Throwable,? extends T> fn)

当当前 CompletableFuture 因异常而未能正常完成时，应用给定的 Function 处理异常，并返回一个新的 CompletableFuture，其结果为 Function 应用后的值。

b. handle(BiFunction<? super T, Throwable, ? extends U> fn)

无论当前 CompletableFuture 正常完成还是因异常未能完成，都会应用给定的 BiFunction 处理结果或异常，并返回一个新的 CompletableFuture。

4. 其他重要方法

a. allOf(CompletableFuture<?>... cfs)

创建一个新的 CompletableFuture，当所有给定的 CompletableFuture 都完成（不论成功与否）时，新 CompletableFuture 完成。

b. anyOf(CompletableFuture<?>... cfs)

创建一个新的 CompletableFuture，当任意一个给定的 CompletableFuture 完成时，新 CompletableFuture 完成。

实战应用

CompletableFuture 的使用场景很广泛，例如

  1. 异步数据库查询与结果合并
  2. 微服务间异步通信
  3. 并行任务执行与结果汇总
  4. 异步事件处理与通知

这里以第一个场景举例： 场景：在一个订单处理系统中，需要查询订单的详细信息、关联的商品信息以及用户的个人信息。为减少查询延迟，可以使用 CompletableFuture 对每个查询进行异步执行，并在所有查询完成后合并结果。 示例：

如果我们不使用Java8提供的这个CompletableFuture 来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

@Service
@RequiredArgsConstructor
public class OrderProcessingServiceLegacy {
    private final OrderRepository orderRepo;
    private final ProductRepository productRepo;
    private final UserRepository userRepo;

    public OrderDetails fetchOrderDetails(int orderId) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        CountDownLatch orderLatch = new CountDownLatch(1);
        CountDownLatch productsLatch = new CountDownLatch(1);
        CountDownLatch userLatch = new CountDownLatch(1);

        Order order = null;
        List<Product> products = null;
        User user = null;

        // 异步查询订单
        executor.execute(() -> {
            try {
                order = orderRepo.findOrderById(orderId);
                orderLatch.countDown();
            } finally {
                productsLatch.countDown();
            }
        });

        // 异步查询商品
        executor.execute(() -> {
            try {
                products = productRepo.findProductsByOrderId(orderId);
            } finally {
                productsLatch.countDown();
            }
        });

        // 异步查询用户（等待订单查询完成后再执行）
        executor.execute(() -> {
            try {
                orderLatch.await(); // 确保订单查询已完成
                user = userRepo.findUserById(order.getCustomerId());
            } finally {
                userLatch.countDown();
            }
        });

        // 等待所有查询完成
        userLatch.await();

        return new OrderDetails(order, products, user);
    }

    // ... 其他方法 ...
	@Data
	@AllArgsConstructor 
    public static class OrderDetails {
        private final Order order;
        private final List<Product> products;
        private final User user;
    }
}

使用CompletableFuture实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Service
@RequiredArgsConstructor
public class OrderProcessingService {
    private final OrderRepository orderRepo;
    private final ProductRepository productRepo;
    private final UserRepository userRepo;
	private final ThreadPoolExecutor executor;


    public CompletableFuture<OrderDetails> fetchOrderDetails(int orderId) {

        CompletableFuture<Order> orderFuture = CompletableFuture.supplyAsync(() -> orderRepo.findOrderById(orderId), executor);
        CompletableFuture<List<Product>> productsFuture = CompletableFuture.supplyAsync(() -> productRepo.findProductsByOrderId(orderId), executor);
        CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> userRepo.findUserById(order.getCustomerId()), executor);

        return CompletableFuture.allOf(orderFuture, productsFuture, userFuture)
                .thenApplyAsync(unused -> {
                    Order order = orderFuture.join();
                    List<Product> products = productsFuture.join();
                    User user = userFuture.join();

                    return new OrderDetails(order, products, user);
                }, executor);
    }

    // ... 其他方法 ...
	@Data
    public static class OrderDetails {
        private final Order order;
        private final List<Product> products;
        private final User user;

    }
}

在这个示例中：

  • 使用了CompletableFuture之后，代码量减少了，整洁度和可读性也得到提高。
  • fetchOrderDetails 方法接受一个订单 ID，使用 CompletableFuture.supplyAsync() 异步查询订单、商品和用户信息。
  • 使用 CompletableFuture.allOf() 监控所有查询的完成状态。
  • 当所有查询完成时，使用 thenApplyAsync() 合并结果，创建一个包含完整订单详情的 OrderDetails 对象。

小结

CompletableFuture 作为 Java 8 引入的重要异步编程工具，极大地提升了 Java 平台在应对高并发、高性能场景的能力。 结合 Java 8 的并行流（Stream.parallel()）与 CompletableFuture，可以轻松实现数据集的并行处理和结果聚合。 下次给大家聊聊Stream.parallel()。

阅读全文 »

发表于 | 分类于

哈喽，大家好，我是了不起。

当你遇到PPT的时候，你的内心是什么样子的。

如果需要你写PPT了，那么有几个时间点，你要进行述职汇报，大概率是升职了。或者作为程序员，你的代码之路逐渐走向尾声，以后更多的是需要进行汇报工作，此时你需要领导他人，然后再也没有时间写代码了。关于PPT，每一个程序员都应该重视，毕竟这是你保留饭碗的一项硬技能！

阅读全文 »

发表于 | 分类于

在Java编程中，日期和时间处理是一个常见但也是复杂的任务。尽管Java提供了内置的Date类来处理日期和时间，但在实际开发中，我们常常遇到一些问题和挑战，因此不建议过度依赖Date类。本文将深入探讨这些问题，并提供一些替代方案，以帮助开发人员更好地处理日期和时间。

线程安全问题

Date类是可变的，这意味着它的状态可以在对象创建后被修改。因此，如果多个线程同时访问和修改同一个Date对象，可能会导致竞态条件或其他并发问题。例如，考虑以下代码片段：

1
2
3
4
5
6
7
8
Date currentDate = new Date();

// 线程1
SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
String formattedDate = formatter.format(currentDate);

// 线程2
currentDate.setTime(0);

在这个例子中，如果线程1正在格式化日期时，线程2修改了当前日期对象的时间，那么最终的格式化结果可能会与预期不符。

日期格式化困难

Date类虽然可以表示一个特定的日期和时间，但它不提供直接的方法来格式化日期。通常情况下，我们需要使用SimpleDateFormat类来格式化Date对象，但这也会带来一些问题。例如，考虑以下代码：

1
2
3
Date currentDate = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
String formattedDate = formatter.format(currentDate);

这段代码看起来很简单，但是如果在多线程环境中使用同一个SimpleDateFormat实例，会导致线程安全问题。此外，SimpleDateFormat的模式字符串不易于记忆和理解，容易出错。

过时的API

Date类及其相关的API在Java 8中被认为是过时的。取而代之的是java.time包中的新日期和时间API。这些新API提供了更丰富的功能，更好的类型安全性和不可变性，以及更好的设计来应对一些常见的日期和时间问题。例如，考虑使用新API创建一个表示当前日期的示例：

1
LocalDate currentDate = LocalDate.now();

这比使用Date类简单得多，并且避免了Date类的一些问题。

时区问题

Date类在处理时区时可能会出现问题。它默认使用系统的时区，这可能会导致在跨时区应用程序中产生错误的日期和时间计算。例如，考虑以下代码：

1
2
Date currentDate = new Date();
System.out.println(currentDate);

这段代码在不同的时区中可能会产生不同的输出，这取决于系统的默认时区设置。

替代方案

  1. 如果你是使用的jdk8以及之后的版本，建议使用java.time包： 使用Java 8引入的新日期和时间API，如LocalDate、LocalTime、LocalDateTime等。这些类是不可变的、线程安全的，而且提供了更丰富的功能，更适合现代Java应用程序的需求。

  2. 如果你是使用的jdk7以及之前的版本，建议使用第三方库来操作时间： 如Joda-Time。Joda-Time提供了类似于java.time的功能，并且在Java 8之前广受欢迎。

JDK8 常用时间API

Java 8引入了全新的日期和时间API，位于java.time包中，用于更方便、更安全地处理日期和时间。这个API提供了许多新的类和方法，以及更丰富的功能，旨在解决以前Date类所存在的问题。下面详细介绍Java 8的时间API，并举一些使用示例：

  1. LocalDate：表示日期，不包含时间信息，是不可变的。
1
2
LocalDate today = LocalDate.now(); // 当前日期
LocalDate birthday = LocalDate.of(2024, 3, 11); // 指定日期
  1. LocalTime：表示时间，不包含日期信息，也是不可变的。
1
2
LocalTime now = LocalTime.now(); // 当前时间
LocalTime lunchTime = LocalTime.of(12, 30); // 指定时间
  1. LocalDateTime：表示日期和时间，不包含时区信息，同样是不可变的。
1
2
LocalDateTime currentTime = LocalDateTime.now(); // 当前日期和时间
LocalDateTime specificDateTime = LocalDateTime.of(2023, Month.JULY, 4, 13, 30); // 指定日期和时间
  1. ZonedDateTime：表示带有时区的日期和时间，可以明确表示不同时区的日期时间信息。
1
2
3
ZonedDateTime currentDateTime = ZonedDateTime.now(); // 当前日期和时间（带时区）
ZoneId newYorkZone = ZoneId.of("America/New_York");
ZonedDateTime newYorkTime = ZonedDateTime.now(newYorkZone); // 纽约当前日期和时间
  1. Duration：表示两个时间点之间的时间间隔。
1
2
3
4
LocalDateTime start = LocalDateTime.of(2023, Month.JANUARY, 1, 8, 0);
LocalDateTime end = LocalDateTime.of(2023, Month.JANUARY, 1, 12, 30);
Duration duration = Duration.between(start, end);
long hours = duration.toHours(); // 计算小时数
  1. DateTimeFormatter：用于格式化和解析日期时间。
1
2
3
4
LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter); // 格式化为字符串
LocalDateTime parsedDateTime = LocalDateTime.parse("2023-07-04 13:30:00", formatter); // 解析字符串为日期时间
  1. TemporalAdjusters：提供了各种调整日期的方法。
1
2
3
LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth()); 
// 获取本月的第一天
LocalDate nextTuesday = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.TUESDAY)); // 获取下一个星期二

通过使用这些新的类和方法，Java 8的时间API使得处理日期和时间变得更加简单、直观和安全。它提供了更丰富的功能和更好的设计，可以更好地满足现代Java应用程序的需求，并避免了以前Date类所存在的问题。

阅读全文 »

发表于 | 分类于

hello，今天带大家了解一下这个熟悉又陌生的关键字：volatile。

在Java多线程编程中，保证线程安全性是至关重要的。而volatile关键字是实现线程安全性的一种关键机制。

为什么熟悉又陌生呢？Java开发者几乎全都用到过这个关键字，但是又不记得什么时候用了它。

1. volatile关键字的原理

volatile关键字主要用于保证变量在多线程环境下的可见性和禁止指令重排序。

当一个变量被volatile修饰时，线程在读取这个变量的值时将直接从主内存中读取，而不是从线程的本地缓存中读取。

同样地，当一个线程修改了volatile变量的值时，这个变化将立即写回到主内存中，而不是仅仅保存在线程的本地缓存中。

2. volatile关键字的作用

  • 保证可见性：在多线程环境下，如果一个线程修改了volatile变量的值，那么其他线程将立即看到这个变化。这样可以避免线程间的数据不一致性问题。
  • 禁止指令重排序：volatile关键字还可以防止编译器和处理器对代码的优化，确保指令按照程序的顺序执行，避免出现意料之外的行为。

3. volatile关键字的正确使用方法

  • 适用场景：volatile适用于那些被多个线程访问但并不涉及复合操作（例如递增操作）的变量。典型的使用场景包括状态标志、控制变量等。
  • 不适用场景：不要将volatile用于需要原子性操作的场景，因为volatile并不能保证原子性。对于需要原子性操作的场景，应该使用锁或者Atomic原子类。

4. 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class VolatileExample {
    private volatile boolean flag = false;

    public void startTask() {
        // 启动一个线程来修改flag的值
        new Thread(() -> {
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("Flag has been set to true.");
        }).start();
    }

    public void monitorTask() {
        // 启动一个线程来检查flag的值
        new Thread(() -> {
            while (!flag) {
                // 循环等待，直到flag变为true
            }
            System.out.println("Flag is now true. Task can proceed.");
        }).start();
    }

    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        example.startTask();
        example.monitorTask();
    }
}

在这个示例中，我们有两个线程，一个线程调用startTask()方法来修改flag的值为true，另一个线程调用monitorTask()方法来检查flag的值是否为true。在flag没有被volatile修饰的情况下，可能会出现monitorTask()方法陷入死循环的情况，因为它无法及时获取到flag的最新值。但是，由于flag被volatile修饰，线程可以立即看到flag的变化，因此可以正确地退出循环，从而避免了可能出现的问题。

实际应用

事实上，这个简单的示例代码，在实际使用中，几乎是用不到它这种写法；那到底是怎么使用的这个volatile呢？

其实在Java中，java.util.concurrent.atomic包提供了一组原子类，比如AtomicInteger、AtomicLong、AtomicBoolean等，它们提供了一种无锁的线程安全机制，以确保对变量的操作是原子性的。

当谈到Atomic原子类的实现原理时，CAS（Compare and Swap）操作是其中的关键。CAS是一种乐观锁技术，它涉及比较内存中的值和预期值，如果相等，则使用新值替换内存中的值。在Java中，CAS是通过Unsafe类实现的，它是一种硬件级别的原子性操作。

但是，CAS操作本身无法解决线程可见性的问题，这就是volatile关键字的作用。volatile关键字可以确保变量的写操作立即可见于其他线程，从而解决了线程之间的可见性问题。因此，Atomic原子类是结合了CAS和volatile关键字来实现线程安全。

因此，结合了CAS和volatile关键字，Atomic原子类能够在无锁的情况下实现线程安全，提供了一种高效的并发编程解决方案。CAS保证了原子性，volatile保证了可见性，两者结合起来提供了一个强大的多线程环境下的并发控制机制。

小结

日常开发中，我们一般情况下都是直接使用的Atomic原子类来保证线程安全的情况，并不会去直接使用volatile关键字，乍一看这个volatile还真是熟悉又陌生呢！

阅读全文 »

发表于 | 分类于

哈喽，大家好，我是了不起。

日常开发中或者面试的时候经常会遇到身份验证的问题，下面这些都是关于身份验证和授权的常用技术。

Session、Cookie、JWT、Token、SSO和OAuth 2.0 这些都是什么，在我们的应用程序中有什么用，我们来看看！

阅读全文 »