第18章_时间处理

gong_yz大约 17 分钟JAVAJAVASE

1、什么是时区

1.1 时区

时区是地球上的区域使用同一个时间定义。以前,人们通过观察太阳的位置(时角)决定时间,这就使得不同经度的地方的时间有所不同(地方时)。1863年,首次使用时区的概念。时区通过设立一个区域的标准时间部分地解决了这个问题。

世界各个国家位于地球不同位置上,因此不同国家,特别是东西跨度大的国家日出、日落时间必定有所偏差。这些偏差就是所谓的时差。

为了照顾到各地区的使用方便,又使其他地方的人容易将本地的时间换算到别的地方时间上去。有关国际会议决定将地球表面按经线从东到西,划成一个个区域,并且规定相邻区域的时间相差1小时。在同一区域内的东端和西端的人看到太阳升起的时间最多相差不过1小时。当人们跨过一个区域,就将自己的时钟校正1小时(向西减1小时,向东加1小时),跨过几个区域就加或减几小时。这样使用起来就很方便。现今全球共分为24个时区。由于实用上常常1个国家,或1个省份同时跨着2个或更多时区,为了照顾到行政上的方便,常将1个国家或1个省份划在一起。所以时区并不严格按南北直线来划分,而是按自然条件来划分。例如,中国幅员宽广,差不多跨5个时区,但为了使用方便简单,实际上在只用东八时区的标准时即北京时间为准。

北京时间比洛杉矶时间早15或者16个小时。具体和时令有关。 北京时间比纽约时间早12或者13个小时。具体和时令有关。

1.2 冬令时和夏令时

夏令时、冬令时的出现,是为了充分利用夏天的日照,所以时钟要往前拨快一小时,冬天再把表往回拨一小时。其中夏令时从3月第二个周日持续到11月第一个周日。

冬令时: 北京和洛杉矶时差:16 北京和纽约时差:13

夏令时: 北京和洛杉矶时差:15 北京和纽约时差:12


2、时间戳

时间戳(timestamp),一个能表示一份数据在某个特定时间之前已经存在的、 完整的、 可验证的数据,通常是一个字符序列,唯一地标识某一刻的时间。

时间戳是指格林威治时间 1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒) 起至现在的总秒数。通俗的讲, 时间戳是一份能够表示一份数据在一个特定时间点已经存在的完整的可验证的数据。


3、几种常见时间的含义和关系

CET,UTC,GMT,CST的含义和关系

3.1 CET

欧洲中部时间(英語:Central European Time,CET)是比世界标准时间(UTC)早一个小时的时区名称之一。它被大部分欧洲国家和部分北非国家采用。冬季时间为UTC+1,夏季欧洲夏令时为UTC+2。

3.2 UTC

协调世界时,又称世界标准时间或世界协调时间,简称UTC,从英文“Coordinated Universal Time”/法文“Temps Universel Cordonné”而来。台湾采用CNS 7648的《资料元及交换格式–资讯交换–日期及时间的表示法》(与ISO 8601类似)称之为世界统一时间。中国大陆采用ISO 8601-1988的国标《数据元和交换格式信息交换日期和时间表示法》(GB/T 7408)中称之为国际协调时间。协调世界时是以原子时秒长为基础,在时刻上尽量接近于世界时的一种时间计量系统。

3.3 GMT

格林尼治标准时间(旧译格林尼治平均时间或格林威治标准时间;英语:Greenwich Mean Time,GMT)是指位于英国伦敦郊区的皇家格林尼治天文台的标准时间,因为本初子午线被定义在通过那里的经线。

3.4 CST

北京时间,China Standard Time,又名中国标准时间,是中国的标准时间。在时区划分上,属东八区,比协调世界时早8小时,记为UTC+8,与中华民国国家标准时间(旧称“中原标准时间”)、香港时间和澳门时间和相同。當格林威治時間為凌晨0:00時,中國標準時間剛好為上午8:00。

3.5 关系

CET=UTC/GMT + 1小时

CST=UTC/GMT +8 小时

CST=CET + 7 小时


4、SimpleDateFormat的线程安全性问题

4.1 SimpleDateFormat用法

4.1.1 SimpleDateFormat常用方法

SimpleDateFormat是Java提供的一个格式化和解析日期的工具类。它允许进行格式化(日期 -> 文本)、解析(文本 -> 日期)和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。

在Java中,可以使用SimpleDateFormat的format方法,将一个Date类型转化成String类型,并且可以指定输出格式。

Date转String

Date data = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dataStr = sdf.format(data);
System.out.println(dataStr);

以上代码,转换的结果是:2022-08-12 15:02:46,日期和时间格式由"日期和时间模式"字符串指定。如果你想要转换成其他格式,只要指定不同的时间模式就行了。

在Java中,可以使用SimpleDateFormat的parse方法,将一个String类型转化成Date类型。

// String转Data
System.out.println(sdf.parse(dataStr));

4.1.2 日期和时间模式表达方法

SimpleDateFormat是Java提供的一个格式化和解析日期的工具类。它允许进行格式化(日期 -> 文本)、解析(文本 -> 日期)和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。

在Java中,可以使用SimpleDateFormat的format方法,将一个Date类型转化成String类型,并且可以指定输出格式。

// Date转String
Date data = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dataStr = sdf.format(data);
System.out.println(dataStr);

在使用SimpleDateFormat的时候,需要通过字母来描述时间元素,并组装成想要的日期和时间模式。常用的时间元素和字母的对应表如下:

image-20230313174153648
image-20230313174153648

模式字母通常是重复的,其数量确定其精确表示。如下表是常用的输出格式的表示方法。

image-20230313174202645
image-20230313174202645

4.1.3 输出不同时区的时间

默认情况下,如果不指明,在创建日期的时候,会使用当前计算机所在的时区作为默认时区,这也是为什么我们通过只要使用new Date()就可以获取中国的当前时间的原因。

那么,如何在Java代码中获取不同时区的时间呢?SimpleDateFormat可以实现这个功能。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
System.out.println(sdf.format(Calendar.getInstance().getTime()));

以上代码,转换的结果是: 2022-08-12 00:09:35 。既中国的时间是8月12日的15点,而美国洛杉矶时间比中国北京时间慢了16个小时(这还和冬夏令时有关系,就不详细展开了)。

当然,这不是显示其他时区的唯一方法,不过本文主要为了介绍SimpleDateFormat,其他方法暂不介绍了。

4.2 SimpleDateFormat线程安全性

由于SimpleDateFormat比较常用,而且在一般情况下,一个应用中的时间显示模式都是一样的,所以很多人愿意使用如下方式定义SimpleDateFormat:

public class Main {

    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     
    public static void main(String[] args) {
        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("America/New_York"));
        System.out.println(simpleDateFormat.format(Calendar.getInstance().getTime()));
    }

}

这种定义方式,存在很大的安全隐患。

问题重现

我们来看一段代码,以下代码使用线程池来执行时间输出。

/** * @author Hollis */
public class Main {
	/**
     * 定义一个全局的SimpleDateFormat
     */
	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	/**
     * 使用ThreadFactoryBuilder定义一个线程池
     */
	private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
	        .setNameFormat("demo-pool-%d").build();
	private static ExecutorService pool = new ThreadPoolExecutor(5, 200,
	        0L, TimeUnit.MILLISECONDS,
	        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
	/**
     * 定义一个CountDownLatch,保证所有子线程执行完之后主线程再执行
     */
	private static CountDownLatch countDownLatch = new CountDownLatch(100);
    
	public static void main(String[] args) {
		//定义一个线程安全的HashSet
		Set<String> dates = Collections.synchronizedSet(new HashSet<String>());
		for (int i = 0; i < 100; i++) {
			//获取当前时间
			Calendar calendar = Calendar.getInstance();
			int finalI = i;
			pool.execute(() -> {
				//时间增加
				calendar.add(Calendar.DATE, finalI);
				//通过simpleDateFormat把时间转换成字符串
				String dateString = simpleDateFormat.format(calendar.getTime());
				//把字符串放入Set中
				dates.add(dateString);
				//countDown
				countDownLatch.countDown();
			}
			);
		}
		//阻塞,直到countDown数量为0
		countDownLatch.await();
		//输出去重后的时间个数
		System.out.println(dates.size());
	}
}

以上代码,其实比较简单,很容易理解。就是循环一百次,每次循环的时候都在当前时间基础上增加一个天数(这个天数随着循环次数而变化),然后把所有日期放入一个线程安全的、带有去重功能的Set中,然后输出Set中元素个数。

正常情况下,以上代码输出结果应该是100。但是实际执行结果是一个小于100的数字。

原因就是因为SimpleDateFormat作为一个非线程安全的类,被当做了共享变量在多个线程中进行使用,这就出现了线程安全问题。

在阿里巴巴Java开发手册的第一章第六节——并发处理中关于这一点也有明确说明:

image-20230313174405588
image-20230313174405588

那么,接下来我们就来看下到底是为什么,以及该如何解决。

4.3 线程不安全原因

通过以上代码,我们发现了在并发场景中使用SimpleDateFormat会有线程安全问题。其实,JDK文档中已经明确表明了SimpleDateFormat不应该用在多线程场景中:

Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally.

那么接下来分析下为什么会出现这种问题,SimpleDateFormat底层到底是怎么实现的?

我们跟一下SimpleDateFormat类中format方法的实现其实就能发现端倪。

image-20230313174452437
image-20230313174452437

SimpleDateFormat中的format方法在执行过程中,会使用一个成员变量calendar来保存时间。这其实就是问题的关键。

由于我们在声明SimpleDateFormat的时候,使用的是static定义的。那么这个SimpleDateFormat就是一个共享变量,随之,SimpleDateFormat中的calendar也就可以被多个线程访问到。

假设线程1刚刚执行完calendar.setTime把时间设置成2018-11-11,还没等执行完,线程2又执行了calendar.setTime把时间改成了2018-12-12。这时候线程1继续往下执行,拿到的calendar.getTime得到的时间就是线程2改过之后的。

除了format方法以外,SimpleDateFormat的parse方法也有同样的问题。

所以,不要把SimpleDateFormat作为一个共享变量使用

4.4 如何解决

解决方法有很多,这里介绍三个比较常用的方法:

  1. 使用局部变量
  2. 加同步锁
  3. 使用ThreadLocal

4.4.1 使用局部变量

代码

for (int i = 0; i < 100; i++) {
    //获取当前时间
    Calendar calendar = Calendar.getInstance();
    int finalI = i;
    pool.execute(() -> {
        // SimpleDateFormat声明成局部变量
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //时间增加
        calendar.add(Calendar.DATE, finalI);
        //通过simpleDateFormat把时间转换成字符串
        String dateString = simpleDateFormat.format(calendar.getTime());
        //把字符串放入Set中
        dates.add(dateString);
        //countDown
        countDownLatch.countDown();
    });
}

SimpleDateFormat变成了局部变量,就不会被多个线程同时访问到了,就避免了线程安全问题。

4.4.2 加同步锁

除了改成局部变量以外,还有一种方法大家可能比较熟悉的,就是对于共享变量进行加锁。

for (int i = 0; i < 100; i++) {
    //获取当前时间
    Calendar calendar = Calendar.getInstance();
    int finalI = i;
    pool.execute(() -> {
        //加锁
        synchronized (simpleDateFormat) {
            //时间增加
            calendar.add(Calendar.DATE, finalI);
            //通过simpleDateFormat把时间转换成字符串
            String dateString = simpleDateFormat.format(calendar.getTime());
            //把字符串放入Set中
            dates.add(dateString);
            //countDown
            countDownLatch.countDown();
        }
    });
}

通过加锁,使多个线程排队顺序执行。避免了并发导致的线程安全问题。

其实以上代码还有可以改进的地方,就是可以把锁的粒度再设置的小一点,可以只对simpleDateFormat.format这一行加锁,这样效率更高一些。

4.4.3 使用ThreadLocal

第三种方式,就是使用 ThreadLocal。 ThreadLocal 可以确保每个线程都可以得到单独的一个 SimpleDateFormat 的对象,那么自然也就不存在竞争问题了。

/**
 * 使用ThreadLocal定义一个全局的SimpleDateFormat
 */
private static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {
	@Override
	   protected SimpleDateFormat initialValue() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	}
};

用法

String dateString = simpleDateFormatThreadLocal.get().format(calendar.getTime());

用 ThreadLocal 来实现其实是有点类似于缓存的思路,每个线程都有一个独享的对象,避免了频繁创建对象,也避免了多线程的竞争。

当然,以上代码也有改进空间,就是,其实SimpleDateFormat的创建过程可以改为延迟加载。这里就不详细介绍了。

4.4.4 使用DateTimeFormatter

如果是Java8应用,可以使用DateTimeFormatter代替SimpleDateFormat,这是一个线程安全的格式化工具类。就像官方文档中说的,这个类 simple beautiful strong immutable thread-safe。

解析日期

String dateStr= "2016年10月25日";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
LocalDate date= LocalDate.parse(dateStr, formatter);

日期转换为字符串

LocalDateTime now = LocalDateTime.now();
DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm a");
String nowStr = now .format(format);
System.out.println(nowStr);

5、Java 8中的时间处理

5.1 背景

Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。

在旧版的 Java 中,日期时间 API 存在诸多问题,其中有:

  • 非线程安全 − java.util.Date 是非线程安全的,所有的日期类都是可变的,这是Java日期类最大的问题之一。
  • 设计很差 − Java的日期/时间类的定义并不一致,在java.util和java.sql的包中都有日期类,此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间,而java.sql.Date仅包含日期,将其纳入java.sql包并不合理。另外这两个类都有相同的名字,这本身就是一个非常糟糕的设计。
  • 时区处理麻烦 − 日期类并不提供国际化,没有时区支持,因此Java引入了java.util.Calendar和java.util.TimeZone类,但他们同样存在上述所有的问题。

在Java8中, 新的时间及⽇期API位于java.time包中, 该包中有哪些重要的类。 分别代表了什么?

  • Instant: 时间戳
  • Duration: 持续时间, 时间差
  • LocalDate: 只包含⽇期, ⽐如: 2016-10-20
  • LocalTime: 只包含时间, ⽐如: 23:12:10
  • LocalDateTime: 包含⽇期和时间, ⽐如: 2016-10-20 23:14:21
  • Period: 时间段
  • ZoneOffset: 时区偏移量, ⽐如: +8:00
  • ZonedDateTime: 带时区的时间
  • Clock: 时钟, ⽐如获取⽬前美国纽约的时间

新的java.time包涵盖了所有处理日期,时间,日期/时间,时区,时刻(instants),过程(during)与时钟(clock)的操作。

5.2 LocalTime 和 LocalDate的区别

LocalDate表示日期,年月日, LocalTime表示时间,时分秒

5.3 获取当前时间

在Java8中,使用如下方式获取当前时间:

LocalDate today = LocalDate.now();
int year = today.getYear();
int month = today.getMonthValue();
int day = today.getDayOfMonth();
System.out.println("Year : %d Month : %d day : %d t %n", year,month, day);

5.4 创建指定日期的时间

LocalDate date = LocalDate.of(2018, 01, 01);

5.5 检查闰年

直接使⽤LocalDate的isLeapYear即可判断是否闰年

LocalDate nowDate = LocalDate.now();
//判断闰年
boolean leapYear = nowDate.isLeapYear();

5.6 计算两个⽇期之间的天数和⽉数

在Java 8中可以⽤java.time.Period类来做计算。

Period period = Period.between(LocalDate.of(2018, 1, 5),LocalDate.of(2018, 2, 5));

另外方法:

 /**
   * 计算两个时间点之间的天数
   */
private static void getBetweenDay() {
	LocalDate start = LocalDate.of(2018, 2, 12);
	LocalDate now = LocalDate.now();
	System.out.println("两个时间之间的天数是:" + TimesUtils.getBetweenDay(start, now) + " 天。");
}
 /**
   * 计算两个时间点之间的天数
   */
public static long getBetweenDay(LocalDate start, LocalDate end) {
	return end.toEpochDay() - start.toEpochDay();
}

LocalDate.toEpochDay()

将日期转换成Epoch 天,Epoch就是从1970-01-01(ISO)。开始的天数,和那个时间戳是一个道理,时间戳是秒数。


6、为什么日期格式化时使用y表示年,而不能用Y

6.1 y表示Year 而Y表示Week Year

在使用SimpleDateFormat的时候,需要通过字母来描述时间元素,并组装成想要的日期和时间模式。常用的时间元素和字母的对应表(JDK 1.8)如下:

image-20230313175342529
image-20230313175342529

可以看到,y表示Year ,而Y表示Week Year。

6.2 什么是Week Year?

6.2.1 介绍

我们知道,不同的国家对于一周的开始和结束的定义是不同的。如在中国,我们把星期一作为一周的第一天,而在美国,他们把星期日作为一周的第一天。

同样,如何定义哪一周是一年当中的第一周?这也是一个问题,有很多种方式。

比如下图是2019年12月-2020年1月的一份日历。

image-20230313175453955
image-20230313175453955

到底哪一周才算2020年的第一周呢?不同的地区和国家,甚至不同的人,都有不同的理解。

  1. 1月1日是周三,到下周三(1月8日),这7天算作这一年的第一周。
  2. 因为周日(周一)才是一周的第一天,所以,要从2020年的第一个周日(周一)开始往后推7天才算这一年的第一周。
  3. 因为12.29、12.30、12.31是2019年,而1.1、1.2、1.3才是2020年,而1.4周日是下一周的开始,所以,第一周应该只有1.1、1.2、1.3这三天。

6.2.2 ISO 8601

因为不同人对于日期和时间的表示方法有不同的理解,于是,大家就共同制定了了一个国际规范:ISO 8601 。

国际标准化组织的国际标准ISO 8601是日期和时间的表示方法,全称为《数据存储和交换形式·信息交换·日期和时间的表示方法》。

在 ISO 8601中。对于一年的第一个日历星期有以下四种等效说法:

  1. 本年度第一个星期四所在的星期;
  2. 1月4日所在的星期;
  3. 本年度第一个至少有4天在同一星期内的星期;
  4. 星期一在去年12月29日至今年1月4日以内的星期;

根据这个标准,我们可以推算出:

2020年第一周:2019.12.29-2020.1.4

所以,根据ISO 8601标准,2019年12月29日、2019年12月30日、2019年12月31日这两天,其实不属于2019年的最后一周,而是属于2020年的第一周。

6.2.3 JDK针对ISO 8601提供的支持

根据ISO 8601中关于日历星期和日表示法的定义,2019.12.29-2020.1.4是2020年的第一周。

我们希望输入一个日期,然后程序告诉我们,根据ISO 8601中关于日历日期的定义,这个日期到底属于哪一年。

比如我输入2019-12-20,他告诉我是2019;而我输入2019-12-30的时候,他告诉我是2020。

为了提供这样的数据,Java 7引入了「YYYY」作为一个新的日期模式来作为标识。使用「YYYY」作为标识,。再通过SimpleDateFormat就可以得到一个日期所属的周属于哪一年了

所以,当我们要表示日期的时候,一定要使用 yyyy-MM-dd 而不是 YYYY-MM-dd ,这两者的返回结果大多数情况下都一样,但是极端情况就会有问题了。