Java工具集1（深浅拷贝,抽象类和接口，常量创建，ResponseEntity，回调实现线程数据传输，SpringBoot配置文件，线程池，同步队列，netty，ConcurrentHashMap）

1. 深浅拷贝问题：

在开发中遇到一个问题就是关于拷贝的，通过学习，发现，拷贝分为深浅两种类型（主要是针对引用类型），具体的学习网址如下所示：

深浅拷贝只是针对Array与Object这样的引用数据类型。简单来说，浅拷贝只是拷贝了它在栈中存储的指针，它们指向的都是同一个堆内存地址，所以浅拷贝在某些情况会造成改变数据后导致别的另一份数据也同步被改变的情况；而深拷贝是直接将堆内存中存储的数据直接复制一份，不会有浅拷贝互相影响的问题。

Object.assign()  实现的是浅拷贝。 拷贝对象中的属性如果是基本数据类型将不会受到影响，如果是引用类型则将会受到影响。

相似的方法：Array.prototype.concat()

                     Array.prototype.slice()

递归遍历实现深拷贝。

https://www.cnblogs.com/grow-up-up/p/12810123.html

2. (70条消息) 抽象类（abstract class）和接口（Interface）的区别_自由人生-CSDN博客

https://blog.csdn.net/aptentity/article/details/68942916

3.  Java中创建常量的方式：（三种：接口，常量类和枚举，优先考虑枚举）

https://blog.csdn.net/chenpeng19910926/article/details/76210117

4. Java使用ResponseEntity实现响应体的设计

Spring自带的函数，推荐使用，作为响应体，可以自动转为Json数据。

5.  子线程传输数据给主线程（回调的方式）

https://blog.csdn.net/weixin_43475124/article/details/83930436

@Slf4j
@SpringBootTest
public class Test2 {
    // 通过线程间回调的方式实现数据的传输。
    C c = new C();
    static boolean flag = false;

    @Test
    void ThreadTest() {

        c.setvalue("1234");
        System.out.println("线程执行前的value值：" + c.getvalue());
        Thread mythread = new MyThread(c);
        mythread.start();
        //等待子线程执行结束
        while (!flag) {
            if (!c.getvalue().equals("1234")) {
               // System.out.println("不等于1234");
                break;
            }
        }
        System.out.println("结束" + c.getvalue());
    }

    //回调的结束标识
    public static void callback() {
        System.out.println("子线程结束");
        flag = true;
    }

    class C {
        private String value = "";

        public String getvalue() {
            return value;
        }

        // 处理回调的具体事务
        public void setvalue(String v) {
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                System.out.println("等待时间超时");
//            }
            this.value = v;
        }
    }

    //    启动线程
    class MyThread extends Thread {
        private C cc;

        public MyThread(C cc) {
            this.cc = cc;
        }

        @Override
        public void run() {
            cc.setvalue("Hello");
            Test2.callback();
            System.out.println("子线程执行之后value的值是：" + c.getvalue());
        }
    }

}

6.  SpringBoot配置文件那些事

https://www.cnblogs.com/gc65/p/10624629.html

7. ExecutorService线程池的使用

https://www.cnblogs.com/jfaith/p/11114470.html

8.  SynchronousQueue（线程之间）同步队列详解

https://www.cnblogs.com/flydean/p/synchronousqueue-in-detail.html

9. netty的学习

https://blog.csdn.net/qq_24874939/article/details/86475285

https://www.cnblogs.com/wanpishe/p/10119974.html

https://www.sohu.com/a/272879207_463994

10.ConcurrentHashMap的使用

首先使用该Map的主要原因是他是对map的继承和封装，具有线程安全等特性。可以类比于go语言的sync.map

一般的使用方式就是放在全局的公共类进行封装相关的方法，然后在使用的时候直接进行相关的调用就可以了。

/**
 * @Author GCG
 * @Date：2021/1/15
 * @Description: 功能描述: 全局的ConcurrentHashMap
 */
public class ChannelClientUtil {

    private volatile static Map<String, TopicDataBean> CHANNEL_MAP = new ConcurrentHashMap<>();

    private volatile static Map<String, String> ApplicationL_MAP = new ConcurrentHashMap<>();

    public static String getApplication(String key) {
        return ApplicationL_MAP.get(key);
    }

    public static void setApplication(String clientId, String value) {
        if (clientId == null) {
            return;
        }
        ApplicationL_MAP.put(clientId, value);
    }

    public static void removeApplication(String clientId) {
        if (clientId == null) {
            return;
        }
        ApplicationL_MAP.remove(clientId);
    }


    public static TopicDataBean get(String clientId) {
        return CHANNEL_MAP.get(clientId);
    }

    public static void set(String clientId, TopicDataBean topicDataBean) {
        if (clientId == null) {
            return;
        }
        CHANNEL_MAP.put(clientId, topicDataBean);
    }

    public static void remove(String clientId) {
        if (clientId == null) {
            return;
        }
        CHANNEL_MAP.remove(clientId);
    }

    public static Set<String> keys() {
        return CHANNEL_MAP.keySet();
    }

    public static int keysNumber() {
        return CHANNEL_MAP.size();
    }
}

使用的话就是更简单了：

// 进行写map
ChannelClientUtil.set(“2345”,new TopicDataBean());

//读map
ChannelClientUtil.get(“2345”);