作者：whisper

链接：http://proprogrammar.com:443/article/496

声明：请尊重原作者的劳动，如需转载请注明出处

    新时间日期 API

    使用 LocalDate、 LocalTime、 LocalDateTime

    LocalDate、 LocalTime、 LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

    //1. LocalDate、LocalTime、LocalDateTime
	@Test
	public void test1(){
		LocalDateTime ldt = LocalDateTime.now();
		System.out.println(ldt);
		
		LocalDateTime ld2 = LocalDateTime.of(2016, 11, 21, 10, 10, 10);
		System.out.println(ld2);
		
		LocalDateTime ldt3 = ld2.plusYears(20);
		System.out.println(ldt3);
		
		LocalDateTime ldt4 = ld2.minusMonths(2);
		System.out.println(ldt4);
		
		System.out.println(ldt.getYear());
		System.out.println(ldt.getMonthValue());
		System.out.println(ldt.getDayOfMonth());
		System.out.println(ldt.getHour());
		System.out.println(ldt.getMinute());
		System.out.println(ldt.getSecond());
	}

    Instant 时间戳

    用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算

    Duration 和 Period

    Duration:用于计算两个“时间”间隔
    Period:用于计算两个“日期”间隔

    //2. Instant : 时间戳。 （使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值）
	@Test
	public void test2(){
		Instant ins = Instant.now();  //默认使用 UTC 时区
		System.out.println(ins);
		
		// 东八区时间
		OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));
		System.out.println(odt);
		
		System.out.println(ins.getNano());
		
		// 1970年1月1日 00:00:05
		Instant ins2 = Instant.ofEpochSecond(5);
		System.out.println(ins2);
	}

    //3.
	//Duration : 用于计算两个“时间”间隔
	//Period : 用于计算两个“日期”间隔
	@Test
	public void test3(){
		Instant ins1 = Instant.now();
		
		System.out.println("--------------------");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
		
		Instant ins2 = Instant.now();
		
		System.out.println("所耗费时间为：" + Duration.between(ins1, ins2));
		
		System.out.println("----------------------------------");
		
		LocalDate ld1 = LocalDate.now();
		LocalDate ld2 = LocalDate.of(2011, 1, 1);
		
		Period pe = Period.between(ld2, ld1);
		System.out.println(pe.getYears());
		System.out.println(pe.getMonths());
		System.out.println(pe.getDays());
	}

    日期的操纵

    TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
    TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
    例如获取下个周日：

    //4. TemporalAdjuster : 时间校正器
	@Test
	public void test4(){
	LocalDateTime ldt = LocalDateTime.now();
		System.out.println(ldt);
		
		LocalDateTime ldt2 = ldt.withDayOfMonth(10);
		System.out.println(ldt2);
		
		LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
		System.out.println(ldt3);
		
		//自定义：下一个工作日
		LocalDateTime ldt5 = ldt.with((l) -> {
			LocalDateTime ldt4 = (LocalDateTime) l;
			
			DayOfWeek dow = ldt4.getDayOfWeek();
			
			if(dow.equals(DayOfWeek.FRIDAY)){
				return ldt4.plusDays(3);
			}else if(dow.equals(DayOfWeek.SATURDAY)){
				return ldt4.plusDays(2);
			}else{
				return ldt4.plusDays(1);
			}
		});
		
		System.out.println(ldt5);
		
	}

    解析与格式化

    java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：
    预定义的标准格式
    语言环境相关的格式
    自定义的格式

    //5. DateTimeFormatter : 解析和格式化日期或时间
	@Test
	public void test5(){
//		DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;
		
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");
		
		LocalDateTime ldt = LocalDateTime.now();
		String strDate = ldt.format(dtf);
		
		System.out.println(strDate);
		
		LocalDateTime newLdt = LocalDateTime.parse(strDate, dtf);
		System.out.println(newLdt);
	}

    时区的处理

    Java8 中加入了对时区的支持，带时区的时间为分别为：
    ZonedDate、 ZonedTime、 ZonedDateTime
    其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式
    例如 ： Asia/Shanghai 等
    ZoneId：该类中包含了所有的时区信息
    getAvailableZoneIds() : 可以获取所有时区时区信息
    of(id) : 用指定的时区信息获取 ZoneId 对象

    //6.ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
	@Test
	public void test7(){
		LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
		System.out.println(ldt);
		
		ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
		System.out.println(zdt);
	}
	
	@Test
	public void test6(){
		Set<String> set = ZoneId.getAvailableZoneIds();
		set.forEach(System.out::println);
	}

    与传统日期处理的转换

    下面说一下SimpleDateFormat多线程安全问题及解决

    // SimpleDateFormat多线程安全问题及解决
	public static void main(String[] args) throws Exception {
		// SimpleDateFormat有多线程安全问题
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		
		Callable<Date> task = new Callable<Date>() {

			@Override
			public Date call() throws Exception {
				return sdf.parse("20161121");
			}
			
		};

		ExecutorService pool = Executors.newFixedThreadPool(10);
		
		List<Future<Date>> results = new ArrayList<>();
		
		for (int i = 0; i < 10; i++) {
			results.add(pool.submit(task));
		}
		
		for (Future<Date> future : results) {
			System.out.println(future.get());
		}
		
		pool.shutdown();
		
		//使用ThreadLocal解决多线程安全问题
		Callable<Date> task2 = new Callable<Date>() {

			@Override
			public Date call() throws Exception {
				return DateFormatThreadLocal.convert("20161121");
			}
			
		};

		ExecutorService pool2 = Executors.newFixedThreadPool(10);
		
		List<Future<Date>> results2 = new ArrayList<>();
		
		for (int i = 0; i < 10; i++) {
			results2.add(pool2.submit(task2));
		}
		
		for (Future<Date> future : results2) {
			System.out.println(future.get());
		}
		
		pool2.shutdown();
		
		// 使用java8中的DateTimeFormatter解决多线程安全问题
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
		
		Callable<LocalDate> task3 = new Callable<LocalDate>() {

			@Override
			public LocalDate call() throws Exception {
				LocalDate ld = LocalDate.parse("20161121", dtf);
				return ld;
			}
			
		};

		ExecutorService pool3 = Executors.newFixedThreadPool(10);
		
		List<Future<LocalDate>> results3 = new ArrayList<>();
		
		for (int i = 0; i < 10; i++) {
			results3.add(pool3.submit(task3));
		}
		
		for (Future<LocalDate> future : results3) {
			System.out.println(future.get());
		}
		
		pool3.shutdown();
	}

    private class DateFormatThreadLocal {
	    
    	private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>(){
		
	    	protected DateFormat initialValue(){
	    		return new SimpleDateFormat("yyyyMMdd");
	    	}
		
	    };
	
	    public static final Date convert(String source) throws ParseException{
    		return df.get().parse(source);
    	}

    }

    并行流与串行流

    并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

    Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

    list.parallelStream();
    list.parallelStream().sequential();

    java8的并行在内部是用Fork/Join 框架实现的

    了解 Fork/Join 框架

    Fork/Join 框架： 就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.

    Fork/Join 框架与传统线程池的区别

    采用 “工作窃取”模式（work-stealing）：
    当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能.

    // 使用ForkJoinPool求和0~10000000000L
	@Test
	public void test1(){
		long start = System.currentTimeMillis();
		
		ForkJoinPool pool = new ForkJoinPool();
		ForkJoinTask<Long> task = new ForkJoinCalculate(0L, 10000000000L);
		
		long sum = pool.invoke(task);
		System.out.println(sum);
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费的时间为: " + (end - start)); //112-1953-1988-2654-2647-20663-113808
	}
	
	// 常规求和0~10000000000L
	@Test
	public void test2(){
		long start = System.currentTimeMillis();
		
		long sum = 0L;
		
		for (long i = 0L; i <= 10000000000L; i++) {
			sum += i;
		}
		
		System.out.println(sum);
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费的时间为: " + (end - start)); //34-3174-3132-4227-4223-31583
	}
	
	// 使用parallelStream求和0~10000000000L
	@Test
	public void test3(){
		long start = System.currentTimeMillis();
		
		Long sum = LongStream.rangeClosed(0L, 10000000000L)
							 .parallel()
							 .sum();
		
		System.out.println(sum);
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费的时间为: " + (end - start)); //2061-2053-2086-18926
	}

    private class ForkJoinCalculate extends RecursiveTask<Long>{

        /**
    	 * 
    	 */
    	private static final long serialVersionUID = 13475679780L;
	
    	private long start;
    	private long end;
	
	    private static final long THRESHOLD = 10000L; //临界值
	
    	public ForkJoinCalculate(long start, long end) {
    		this.start = start;
    		this.end = end;
    	}
    	
    	@Override
    	protected Long compute() {
    		long length = end - start;
		
	    	if(length <= THRESHOLD){
	    		long sum = 0;
			
	    		for (long i = start; i <= end; i++) {
	    			sum += i;
	    		}
			
	    		return sum;
	    	}else{
	    		long middle = (start + end) / 2;
			
	    		ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
	    		left.fork(); //拆分，并将该子任务压入线程队列
			
	    		ForkJoinCalculate right = new ForkJoinCalculate(middle+1, end);
	    		right.fork();
			
	    		return left.join() + right.join();
	    	}
	    	
	    }
    }

亲爱的读者：有时间可以点赞评论一下