Java 8 新特性:Java 类库的新特性之日期时间API (Date/Time API )

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
简介: Java 8 新特性:Java 类库的新特性之日期时间API (Date/Time API )

日期时间API (Date/Time API )


1.Java8之前java.util.Date和Calendar类的弊端


1)最开始的时候,Date既要承载日期信息,又要做日期之间的转换,还要做不同日期格式的显示,职责较繁杂(不遵守单一职责)。


后来从JDK 1.1 开始,这三项职责分开了:


使用Calendar类实现日期和时间字段之间转换;

使用DateFormat类来格式化和分析日期字符串;

Date只用来承载日期和时间信息。

现在原有Date中的相应方法已废弃。无论是Date,还是Calendar,都使用着太不方便,这是API没有设计好的地方。

2)令人无语的year和month(month是从0开始的)


eg:

Date date = new Date(2016,1,1);   
System.out.println(date); 

输出结果:Tue Feb 01 00:00:00 CST 3916  

这样得到的结果year为2012+1900,而month明明给定的参数是1,却输出的是二月。

设置日期可以用java.util.Calendar

Calendar calendar = Calendar.getInstance();   
calendar.set(2016, 5, 2);

虽然Calendar年份的传值不需要减去1900,但Calendar的month也是从0开始的,表达5月份应该用4这个数字。

3)java.util.Date与java.util.Calendar中的所有属性都是可变的,且线程不安全。

eg:

public class Test {
  public static void main(String[] args) {
    Calendar birth = Calendar.getInstance();
    birth.set(1975, Calendar.MAY, 26);
    Calendar now = Calendar.getInstance();
    System.out.println(daysBetween(birth, now)); // 输出结果为14963,值不固定
    System.out.println(daysBetween(birth, now)); // 输出结果 显示 0?
  }
}
  public static long daysBetween(Calendar begin, Calendar end) {   
       long daysBetween = 0;   
       while(begin.before(end)) {   
           begin.add(Calendar.DAY_OF_MONTH, 1);   
           daysBetween++;   
      }   
      return daysBetween;   
  } 
}

Note:daysBetween有点问题,如果连续计算两个Date实例的话,第二次会取得0,因为Calendar状态是可变的,考虑到重复计算的场合,最好复制一个新的Calendar。修改代码如下

public static long daysBetween(Calendar begin, Calendar end) {   
  Calendar calendar = (Calendar) begin.clone(); // 复制   
      long daysBetween = 0;   
      while(calendar.before(end)) {   
          calendar.add(Calendar.DAY_OF_MONTH, 1);   
          daysBetween++;   
      }   
      return daysBetween;      
} 

2.简述 新的日期时间API


Java 的日期与时间 API 问题由来已久,Java 8 之前的版本中关于时间、日期及其他时间日期格式化类由于线程安全、重量级、序列化成本高等问题而饱受批评。Java 8 吸收了 Joda-Time 的精华,以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于时钟(Clock),本地日期(LocalDate)、本地时间(LocalTime)、本地日期时间(LocalDateTime)、时区(ZonedDateTime)和持续时间(Duration)的类。历史悠久的 Date 类新增了 toInstant() 方法,用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简化了了日期时间和本地化的管理。


目前Java8新增了java.time包定义的类表示日期-时间概念的规则,很方便使用;最重要的一点是值不可变,且线程安全。


下图是java.time包下的一些主要的类的日期时间 值的格式,方便理解使用:

image.png

Note:不过尽管有了新的API,但仍有一个严重的问题——大量的旧代码和库仍然在使用老的API。现在,Java 8解决了这个问题,它给Date类增加了一个新的方法toInstant(),可以将Date转化成新的实例。这样就可以切换到新的API。


对于新API:


非常有用的值类型:

Instant ----- 与java.util.Date相似

ZonedDateTime ----- ZoneId -时区很重要的时候使用

OffsetDateTime ----- OffsetTime, ZoneOffset -对UTC的偏移处理

Duration, Period ----- 但如果你想找到两个日期之间的时间量,你可能会寻找ChronoUnit代替(详情见下文)

其他有用的类型:

DateTimeFormatter ----- 将日期类型转换成字符串类型

ChronoUnit ----- 计算出两点之间的时间量,例如ChronoUnit.DAYS.between(t1, t2)

TemporalAdjuster ----- 例如date.with(TemporalAdjuster.firstDayOfMonth())

Note:大多数情况下,新的值类型由JDBC提供支持。有一小部分异常,eg:ZonedDateTime在SQL中没有对应的(类型)。


3.Java 新旧日期API的区别

image.png

4.java.time包下的类


4.1 Clock类


Clock类提供了访问当前日期和时间的方法。Clock使用时区来访问当前的instant, date和time。Clock类可以替换 System.currentTimeMillis() 和 TimeZone.getDefault()。


eg:

//Clock 时钟
      Clock clock1 = Clock.systemDefaultZone();//获取系统默认时区 (当前瞬时时间 )
      System.out.println( "系统时间日期:"+clock1.instant() );
      System.out.println( "时间毫秒:"+clock1.millis() );
      final Clock clock = Clock.systemUTC();//获取系统时钟,并将其转换成使用UTC时区的日期和时间
      System.out.println( "时间日期:"+clock.instant() );
      System.out.println( "时间毫秒值:"+clock.millis() );

  System.out.println( "时间毫秒值:"+clock.millis() );

输出结果:

系统时间日期:2016-05-12T07:42:37.883Z

时间毫秒:1463038957894

时间日期:2016-05-12T07:42:37.894Z


时间毫秒值:1463038957894



某一个特定的时间点也可以使用Instant类来表示,Instant类也可以用来创建老的java.util.Date对象。


eg:

Instant instant = clock1.instant();
      Date javadate = Date.from(instant); 
      System.out.println( "date:"+javadate);

  System.out.println( "date:"+javadate);

输出结果:


date:Thu May 12 15:47:00 CST 2016



4.2 ZoneId(时区)


在新API中时区使用ZoneId来表示。时区可以很方便的使用静态方法of()来获取到。时区定义了到UTS时间的时间差,在Instant时间点对象到本地日期对象之间转换的时候是极其重要的。


eg:

    // 输出所有可见的时区ID,eg:Asia/Aden, America/Cuiaba, Etc/GMT+9等
    System.out.println(ZoneId.getAvailableZoneIds());
    ZoneId zone1 = ZoneId.of("Europe/Berlin");
    ZoneId zone2 = ZoneId.of("Brazil/East");
    System.out.println(zone1.getRules());
    System.out.println(zone2.getRules());
    //输出结果: ZoneRules[currentStandardOffset=+01:00]
    //输出结果: ZoneRules[currentStandardOffset=-03:00]

4.3 LocalTime(本地时间)

LocalTime 定义了一个没有时区信息的时间。

eg:

1)获取现在的本地时间

// Get the local date and local time
      final LocalTime time = LocalTime.now();
      final LocalTime timeFromClock = LocalTime.now( clock );
      System.out.println( time );
      System.out.println( timeFromClock );

输出结果:

16:03:23.212

08:03:23.212

2)按时区显示时间

ZoneId zone1 = ZoneId.of("Europe/Berlin");
    ZoneId zone2 = ZoneId.of("Brazil/East");
    LocalTime now1 = LocalTime.now(zone1);
    LocalTime now2 = LocalTime.now(zone2);
    System.out.println("时区:Europe/Berlin---"+now1); 
    System.out.println("时区:Brazil/East---"+now2); 

输出结果:

时区:Europe/Berlin---10:03:23.217

时区:Brazil/East---05:03:23.217

LocalTime 提供了多种工厂方法来简化对象的创建,包括解析时间字符串。

eg:

LocalTime late = LocalTime.of(22, 12, 18);//时分秒
    System.out.println(late); // 输出结果:22:12:18
    DateTimeFormatter germanFormatter = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
        .withLocale(Locale.GERMAN);
    LocalTime leetTime = LocalTime.parse("15:39", germanFormatter);
    System.out.println(leetTime); // 输出结果: 15:39

4.4 LocalDate(本地日期)

LocalDate 表示了一个确切的日期(eg: 2014-03-11)。该对象值是不可变的,使用方式和LocalTime基本一致。

eg:

Clock clock = Clock.systemDefaultZone();// 获取系统默认时区 (当前瞬时时间 )
    // Get the local date and local time
    final LocalDate date = LocalDate.now();
    final LocalDate dateFromClock = LocalDate.now(clock);
    System.out.println(date);
    System.out.println(dateFromClock);

输出结果:

2016-05-12

2016-05-12

从字符串解析一个LocalDate类型和解析LocalTime一样简单.

eg:

    DateTimeFormatter germanFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)
        .withLocale(Locale.GERMAN);
    LocalDate xmas = LocalDate.parse("25.10.2016", germanFormatter);
    System.out.println(xmas);

输出结果:

2016-10-25


4.5 LocalDateTime(本地日期时间)


表示了具体时间和日期。LocalDateTime和LocalTime还有LocalDate一样,都是不可变的。LocalDateTime提供了一些能访问具体字段的方法。


eg:


1)

Clock clock = Clock.systemDefaultZone();// 获取系统默认时区 (当前瞬时时间 )
    // Get the local date/time
    final LocalDateTime datetime = LocalDateTime.now();
    final LocalDateTime datetimeFromClock = LocalDateTime.now(clock);
    System.out.println(datetime);
    System.out.println(datetimeFromClock);

输出结果:

2016-05-12T16:33:17.546

2016-05-12T16:33:17.546

2)

  LocalDateTime sylvester = LocalDateTime.of(2016, Month.DECEMBER, 31, 23, 59, 59);
    DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
    System.out.println(dayOfWeek);      
    Month month = sylvester.getMonth();
    System.out.println(month);        
    long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
    System.out.println(minuteOfDay);  

输出结果:

SATURDAY  

DECEMBER  

1439

只要附加上时区信息,就可以将其转换为一个时间点Instant对象,Instant时间点对象可以很容易的转换为老式的java.util.Date。

eg:

LocalDateTime sylvester = LocalDateTime.of(2016, Month.DECEMBER, 31, 23, 59, 59);
    Instant instant = sylvester
            .atZone(ZoneId.systemDefault())
            .toInstant();
    Date legacyDate = Date.from(instant);
    System.out.println(legacyDate);

输出结果:

Sat Dec 31 23:59:59 CST 2016

格式化LocalDateTime和格式化时间和日期一样的,除了使用预定义好的格式外,我也可以自定义格式。

eg:

  DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM dd, yyyy - HH:mm");
    LocalDateTime parsed = LocalDateTime.parse("05 03, 2016 - 07:13", formatter);
    String string = formatter.format(parsed);
    System.out.println(string);

输出结果:

05 03, 2016 - 07:13


Note:和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的,所以它是线程安全的。


4.6 ZonedDateTime(日期时间和时区信息)


使用ZonedDateTime,它保存有ISO-8601日期系统的日期和时间,而且有时区信息。


eg:

    Clock clock = Clock.systemDefaultZone();// 获取系统默认时区 (当前瞬时时间 )
    // Get the zoned date/time
    final ZonedDateTime zonedDatetime = ZonedDateTime.now();
    final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now(clock);
    final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now(ZoneId.of("America/Los_Angeles"));
    System.out.println(zonedDatetime);
    System.out.println(zonedDatetimeFromClock);
    System.out.println(zonedDatetimeFromZone);

输出结果:


2016-05-12T16:59:55.779+08:00[Asia/Shanghai]

2016-05-12T16:59:55.779+08:00[Asia/Shanghai]

2016-05-12T01:59:55.781-07:00[America/Los_Angeles]


4.7 Duration类


Duration持有的时间精确到纳秒。很容易计算两个日期中间的差异。


eg:求时间差

                // Get duration between two dates
    final LocalDateTime from = LocalDateTime.of(2014, Month.APRIL, 16, 0, 0, 0);//年月日时分秒
    final LocalDateTime to = LocalDateTime.of(2015, Month.APRIL, 16, 23, 59, 59);
    final Duration duration = Duration.between(from, to);
    System.out.println("Duration in days: " + duration.toDays());
    System.out.println("Duration in hours: " + duration.toHours());</span>

输出结果:

Duration in days: 365

Duration in hours: 8783

还有一种获取时间差值的方式:ChronoUnit

ZoneId zone1 = ZoneId.of("America/Cuiaba");
     ZoneId zone2 = ZoneId.of("Brazil/East");
     LocalTime now1 = LocalTime.now(zone1);
     LocalTime now2 = LocalTime.now(zone2);
     long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
     long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
     System.out.println(hoursBetween); // 1
     System.out.println(minutesBetween); // 60

5.新日期时间API示例

eg:(注:感兴趣自己运行结果试试各种方法,很easy。)


import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.chrono.ChronoLocalDateTime;
import java.time.chrono.Chronology;
import java.time.chrono.HijrahChronology;
import java.time.format.DateTimeFormatter;
import java.time.temporal.IsoFields;
import java.util.Date;
public class TimeTest {
  public static void main(String[] args) throws InterruptedException {
    testClock();
//    testInstant();
//    testLocalDateTime();
//    testZonedDateTime();
//    testDuration();
//    testChronology();
//    testNewOldDateConversion();
  }
  public static void testClock() throws InterruptedException {
    // 时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。 
    Clock c1 = Clock.systemUTC(); // 系统默认UTC时钟(当前瞬时时间 
    System.out.println(c1.millis()); // 每次调用将返回当前瞬时时间(UTC)
    //相当于System.currentTimeMillis())
    Clock c2 = Clock.systemDefaultZone(); // 系统默认时区时钟(当前瞬时时间)
    Clock c31 = Clock.system(ZoneId.of("Europe/Paris")); // 巴黎时区
    System.out.println(c31.instant()); // 每次调用将返回当前瞬时时间(UTC)
    Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"));// 上海时区
    System.out.println(c32.instant());// 每次调用将返回当前瞬时时间(UTC)
    Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"));// 固定上海时区时钟
    System.out.println(c4.millis());
    Thread.sleep(1000);
    System.out.println(c4.millis()); // 不变 即时钟时钟在那一个点不动
    Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)); // 相对于系统默认时钟两秒的时钟
    System.out.println(c1.millis());
    System.out.println(c5.millis());
  }
  public static void testInstant() {
    // 瞬时时间 相当于以前的System.currentTimeMillis()
    Instant instant1 = Instant.now();
    System.out.println(instant1.getEpochSecond());// 精确到秒 得到相对于1970-01-01
                            // 00:00:00 UTC的一个时间
    System.out.println(instant1.toEpochMilli()); // 精确到毫秒
    Clock clock1 = Clock.systemUTC(); // 获取系统UTC默认时钟
    Instant instant2 = Instant.now(clock1);// 得到时钟的瞬时时间
    System.out.println(instant2.toEpochMilli());
    Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()); // 固定瞬时时间时钟
    Instant instant3 = Instant.now(clock2);// 得到时钟的瞬时时间
    System.out.println(instant3.toEpochMilli());// equals instant1
  }
  public static void testLocalDateTime() {
    // 使用默认时区时钟瞬时时间创建 Clock.systemDefaultZone() -->即相对于
    // ZoneId.systemDefault()默认时区
    LocalDateTime now = LocalDateTime.now();
    System.out.println(now);
    // 自定义时区
    LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Europe/Paris"));
    System.out.println(now2);// 会以相应的时区显示日期
    // 自定义时钟
    Clock clock = Clock.system(ZoneId.of("Asia/Dhaka"));
    LocalDateTime now3 = LocalDateTime.now(clock);
    System.out.println(now3);// 会以相应的时区显示日期
    // 不需要写什么相对时间 如java.util.Date 年是相对于1900 月是从0开始
    // 2013-12-31 23:59
    LocalDateTime d1 = LocalDateTime.of(2013, 12, 31, 23, 59);
    // 年月日 时分秒 纳秒
    LocalDateTime d2 = LocalDateTime.of(2013, 12, 31, 23, 59, 59, 11);
    // 使用瞬时时间 + 时区
    Instant instant = Instant.now();
    LocalDateTime d3 = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault());
    System.out.println(d3);
    // 解析String--->LocalDateTime
    LocalDateTime d4 = LocalDateTime.parse("2013-12-31T23:59");
    System.out.println(d4);
    LocalDateTime d5 = LocalDateTime.parse("2013-12-31T23:59:59.999");// 999毫秒
                                      // 等价于999000000纳秒
    System.out.println(d5);
    // 使用DateTimeFormatter API 解析 和 格式化
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    LocalDateTime d6 = LocalDateTime.parse("2013/12/31 23:59:59", formatter);
    System.out.println(formatter.format(d6));
    // 时间获取
    System.out.println(d6.getYear());
    System.out.println(d6.getMonth());
    System.out.println(d6.getDayOfYear());
    System.out.println(d6.getDayOfMonth());
    System.out.println(d6.getDayOfWeek());
    System.out.println(d6.getHour());
    System.out.println(d6.getMinute());
    System.out.println(d6.getSecond());
    System.out.println(d6.getNano());
    // 时间增减
    LocalDateTime d7 = d6.minusDays(1);
    LocalDateTime d8 = d7.plus(1, IsoFields.QUARTER_YEARS);
    // LocalDate 即年月日 无时分秒
    // LocalTime即时分秒 无年月日
    // API和LocalDateTime类似就不演示了
  }
  public static void testZonedDateTime() {
    // 即带有时区的date-time 存储纳秒、时区和时差(避免与本地date-time歧义)。
    // API和LocalDateTime类似,只是多了时差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])
    ZonedDateTime now = ZonedDateTime.now();
    System.out.println(now);
    ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
    System.out.println(now2);
    // 其他的用法也是类似的 就不介绍了
    ZonedDateTime z1 = ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]");
    System.out.println(z1);
  }
  public static void testDuration() {
    // 表示两个瞬时时间的时间段
    Duration d1 = Duration.between(Instant.ofEpochMilli(System.currentTimeMillis() - 12323123), Instant.now());
    // 得到相应的时差
    System.out.println(d1.toDays());
    System.out.println(d1.toHours());
    System.out.println(d1.toMinutes());
    System.out.println(d1.toMillis());
    System.out.println(d1.toNanos());
    // 1天时差 类似的还有如ofHours()
    Duration d2 = Duration.ofDays(1);
    System.out.println(d2.toDays());
  }
  public static void testChronology() {
    // 提供对java.util.Calendar的替换,提供对年历系统的支持
    Chronology c = HijrahChronology.INSTANCE;
    ChronoLocalDateTime d = c.localDateTime(LocalDateTime.now());
    System.out.println(d);
  }
  /**
   * 新旧日期转换
   */
  public static void testNewOldDateConversion() {
    Instant instant = new Date().toInstant();
    Date date = Date.from(instant);
    System.out.println(instant);
    System.out.println(date);
  }
}


目录
相关文章
|
6天前
|
Java API 数据处理
探索Java中的Lambda表达式与Stream API
【10月更文挑战第22天】 在Java编程中,Lambda表达式和Stream API是两个强大的功能,它们极大地简化了代码的编写和提高了开发效率。本文将深入探讨这两个概念的基本用法、优势以及在实际项目中的应用案例,帮助读者更好地理解和运用这些现代Java特性。
|
12天前
|
Java 大数据 API
别死脑筋,赶紧学起来!Java之Steam() API 常用方法使用,让开发简单起来!
分享Java Stream API的常用方法,让开发更简单。涵盖filter、map、sorted等操作,提高代码效率与可读性。关注公众号,了解更多技术内容。
|
5月前
|
安全 Java 测试技术
滚雪球学Java(51):掌握Java Date类:用法、弊端与时间戳转换技巧,助你轻松处理日期时间
【6月更文挑战第5天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
77 0
滚雪球学Java(51):掌握Java Date类:用法、弊端与时间戳转换技巧,助你轻松处理日期时间
|
SQL Java 数据库
Java中Date各种相关用法
Java中Date各种相关用法(一) 1.计算某一月份的最大天数 Java代码  Calendar time=Calendar.getInstance(); time.clear(); time.
1155 0
|
8天前
|
监控 安全 Java
在 Java 中使用线程池监控以及动态调整线程池时需要注意什么?
【10月更文挑战第22天】在进行线程池的监控和动态调整时,要综合考虑多方面的因素,谨慎操作,以确保线程池能够高效、稳定地运行,满足业务的需求。
79 38
|
5天前
|
安全 Java
java 中 i++ 到底是否线程安全?
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
java 中 i++ 到底是否线程安全?
|
9天前
|
Java 调度
[Java]线程生命周期与线程通信
本文详细探讨了线程生命周期与线程通信。文章首先分析了线程的五个基本状态及其转换过程,结合JDK1.8版本的特点进行了深入讲解。接着,通过多个实例介绍了线程通信的几种实现方式,包括使用`volatile`关键字、`Object`类的`wait()`和`notify()`方法、`CountDownLatch`、`ReentrantLock`结合`Condition`以及`LockSupport`等工具。全文旨在帮助读者理解线程管理的核心概念和技术细节。
25 1
[Java]线程生命周期与线程通信
|
7天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍,相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中,需要根据具体的需求和场景,合理选择线程创建方式,并注意线程安全、同步、通信等相关问题,以确保程序的正确性和稳定性。
|
1天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中,多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手,他们各自演奏着自己的部分,却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界,让你从零基础到能够编写基本的多线程程序。
8 1
|
5天前
|
缓存 Java 调度
Java中的多线程编程:从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始,逐步深入到Java中实现多线程的方法,包括继承Thread类、实现Runnable接口以及使用Executor框架。此外,我们还将探讨多线程编程中的常见问题和最佳实践,帮助读者在实际项目中更好地应用多线程技术。
12 3