JUC学习之路(概念、TimeUnit及ThreadFactory) （一）

目录

什么是JUC

TImeUnit 工具类

线程工厂(ThreadFactory)

---

什么是JUC

        Java的并发变成(J.U.C) ，本质上来讲就属于多线程的一种更加设计结构合理的开发框架，例如：Java类集是对数据结构的一种开发框架、JavaIO是对操作系统底层支持的一种开发框架，所以JDK本身也是会提供有开发框架支持的。

        J.U.C 是由java.util.concurrent包名称给出的三个首字母缩写，J.U.C的提供是为了方便解决并发编程开发过程之中的性能以及稳定性的设计问题，例如：在传统的多线程开发中，一定可以想到如下的几个机制：
        - 如果要想定义线程的主体操作类需要使用Runnable或者时Callable 接口；
        - 如果要想进行数据的同步处理，那么就需要使用到 synchronized 关键字，这个关键字可以实现同步代码块的定义或者是同步方法的定义，但是性能很差；
        - 如果想要快速的实现变量内容的更新处理，要使用volatile 关键字；
        - 如果要想实现等待和唤醒机制，则需要通过Object类所以同的wait()、notify()、notifyall();
        - 所有的操作全部都加在一起了，也无法有效的避免死锁之类的问题。

        JUC属于一个重度多线程的编程的开发框架，在J.U.C 里面提供了一套新的多线程处理方案，并且这些文案都有其核心实现的理论，本质上就是CAS、AQS，而这些是在最终编程的时候是无法感觉到synchronized 存在的。

 TImeUnit 工具类

        在早期的Java多线开发之中，可以使用的时间单元，Thread.sleep()、Object.wait()

# 1、线程休眠方法，Thread.sleep();
public static void sleep(long millis,int nanos) throws InterruptedException
public static void sleep(long millis, int nanos) throws InterruptedException


# 2、线程等待方法，Object.wait();
public final void wait(long timeout) throws InterruptedException
public final void wait(long timeout, int nanos) throws InterruptedException

         虽然在Thread 的开发中可以使用毫秒和纳秒进行线程单位的配置，但是从实际的开发来说有可能会使用到时、分、秒等概念，所以在Java里面为了进一步简化这种时间的计算管理，提供了一个TimeUnit工具类,该类是一个枚举类。

public enum TimeUnit extends Enum<TimeUnit>

        Java 枚举类的特殊点：除了可以定义一系列的常量外，还可以实现接口，定义方法，或者是定义抽象方法，总之是一个很强大的多例设计模式。

         在整个的TimeUnit 里面定义了大量的常用的时间单元：天(days)、小时(hours)、分钟(minutes)、秒(seconds)、毫秒(milliseconds)、纳秒(nanoseconds)、微秒(microseconds)、除了这些时间单元之外还提供有了一系列的处理方法，例如：时间转换方法、

        范例：

package com.any.timeunit;

import java.util.concurrent.TimeUnit;

/**
 * TimeUnit 的 实例demo
 *
 */
public class TimeUnitTest {
    public static void main(String[] args) {
        long hour = 1;
        // 将小时转为秒
        long convert = TimeUnit.SECONDS.convert(hour, TimeUnit.HOURS);

        System.out.println(convert);

    }
}

        结果： 

         虽然TimeUnit 类很好用，但是从JDK1.8 之后提供一个java.time.Duration 的操作类（间隔），这个类在实际的开发之中经常会被使用到，例如：在学习Spring 开发框架的时候，一般都要进行一个任务间隔的配置。

        - 转换 ：public long convert (Duration duration)

    @Test
    public void convertDuration(){
        // 2小时 + 2小时
        java.time.Duration duration =  java.time.Duration.ofHours(2).plusHours(2);
        System.out.println("时间间隔："+ duration);
        long second = TimeUnit.SECONDS.convert(duration);
        System.out.println("间隔的时间秒数:" + second);
    }

 结果：

         既然TimeUnit 的时间单元的处理如此方便，可以利用TImeUnit 做一个日期时间的计算，例如：计算18天之后的具体日期。采用当前的时间戳+时间偏移量

    @Test
    public void calcullateTime(){
        long current = System.currentTimeMillis();
        long after = current +  TimeUnit.MILLISECONDS.convert(18, TimeUnit.DAYS);
        System.out.println( "18天之后的时间："+
                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(after)));
    }

         结果

         在TimeUnit 中，TimeUnit 类有一个休眠的处理方法，是非常好用的，这个方法可以根据当前的时间单元来进行休眠配置

范例：

    @SneakyThrows
    @Test
    public void testRunnableTimeUnit(){
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(2);
            System.out.println(
                    "【测试TimeUnit.sleep()方法】---" + i);
        }
    }

        在未来进行多线程的开发之中只要是牵扯到时间单位的操作问题的话，同意都建议使用TimeUnit 类进行定义处理，这一点不仅仅是要求，同时也是在J.U.C 里面见到最多的参数的形式。

线程工厂(ThreadFactory)

        在传统的项目开发之中，只要使用了Thread 类就可以直接进行线程的创建，而这种创建的基本形式如下：

        创建线程

    @Test
    public void testThread(){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println("【线程名称】："+Thread.currentThread().getName());
            },"New Thread").start();
        }
    }

        因为我们使用的是一个面向对象的编程语言，那么就需要进行不断的解耦和设计的考虑，毕竟以上代码是直接通过关键字new 进行线程对象的构建，按照面向对象的设计原则来讲此时的代码就不符合标准了，所以在J.U.C 里面改进了对于线程对象的获取机制，提供了一个工厂类的标准接口。

        源码：

package java.util.concurrent;

public interface ThreadFactory {

    Thread newThread(Runnable r);
}

        手动实现这种创建线程的工厂类。

范例：

class AnyThreadFactory implements ThreadFactory { // 创建线程的工厂类

    private static  final ThreadFactory INSTANCE = new AnyThreadFactory();
    private static final String TITLE = "any-"; // 定义线程名称的开头
    private static int count = 0; // 线程的自动计数处理

    private AnyThreadFactory (){
    }

    public static ThreadFactory getInstance(){
        return INSTANCE;
    }

    @Override
    public Thread newThread(Runnable r) {  
    // 此时的操作如果有需要可以进一步改进，例如：通过反射 
        return new Thread(r,TITLE + count++);   // 实例化Thread 类对象
    }
}

测试

    @Test
    public void testThreadFactory(){
        for (int i = 0; i < 10; i++) {
            Thread thread = AnyThreadFactory.getInstance().newThread(()->{
                System.out.println("多线程执行："+Thread.currentThread().getName());
            });
            thread.start();

        }

    }

        输出

        此时所给出的多线程的创建，可以直接利用自定义 的名称进行命名的开头配置，整个想成对象的获取机制更加的规范了

        如果需要进一步规范，需要使用到反射机制。

范例：

class AnyThreadFactory implements ThreadFactory { // 创建线程的工厂类

    private static  final ThreadFactory INSTANCE = new AnyThreadFactory();
    private static final String TITLE = "any-"; // 定义线程名称的开头
    private static int count = 0; // 线程的自动计数处理

    private AnyThreadFactory (){
        //私有化构函数，实现单例
    }

    public static ThreadFactory getInstance(){
        return INSTANCE;
    }

    @Override
    public Thread newThread(Runnable r) {
        try {
            Class<?> clazz = Class.forName("java.lang.Thread");
            Constructor<?> constructor =
                    clazz.getConstructor(Runnable.class, String.class);
            return (Thread) constructor.newInstance(r,TITLE + count++);
        }catch (Exception e){
            return null;
        }

    }
}

         只要是在后续的开发之中，见到了ThreadFactory，就表示的就是进行子线程的创建，这一点在后续分析java线程池机制的时候非常的有用处。