package com.study.pack.xml.circle;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class CircleTest {
    public static void main(String[] args) {
        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("circle.xml"));
        try {
            ServiceA serviceA = (ServiceA)factory.getBean("serviceA");
        } catch (Exception e) {
            String message = e.getMessage();
            System.out.println(message);
        }
    }
}

public class ServiceA {

    private ServiceB serviceB;

    public ServiceA(){}

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    public ServiceB getServiceB() {
        return serviceB;
    }

    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

package com.study.pack.xml.circle;

public class ServiceB {

    private ServiceC serviceC;

    public ServiceB() {}

    public ServiceB(ServiceC serviceC) {
        this.serviceC = serviceC;
    }

    public ServiceC getServiceC() {
        return serviceC;
    }

    public void setServiceC(ServiceC serviceC) {
        this.serviceC = serviceC;
    }
}

package com.study.pack.xml.circle;

public class ServiceC {

    private ServiceA serviceA;

    public ServiceC() {}

    public ServiceC(ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    public ServiceA getServiceA() {
        return serviceA;
    }

    public void setServiceA(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
    @Override
    protected Class<?> getBeanClass(Element element) {
        return User.class;
    }
    // 从element中解析并提取相应的元素
    @Override
    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        String userName = element.getAttribute("userName");
        String email = element.getAttribute("email");
        if (StringUtils.hasText(userName)) {
            builder.addPropertyValue("userName", userName);
        }
        if (StringUtils.hasText(email)) {
            builder.addPropertyValue("email", email);
        }
    }
}

public class MyNamespaceHandler extends NamespaceHandlerSupport {
    @Override
    public void init() {
        registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
    }
}

@Data
public class User {

    private String id;
    private String userName;
    private String email;
    
    @Override
    public String toString() {
        return this.getUserName() + "--" + this.getEmail();
    }
}

public class TestApp {
    public static void main(String[] args) {
        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans3.xml"));
        User u1 = (User)factory.getBean("testbean");
        System.out.println(u1);
    }
}

public class Test {

    public static void main(String[] args) {
        // 1. 定义一个事件发布器
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        // 2.添加WorkEventListener和FreeEventListener事件监听器
        multicaster.addApplicationListener(new WorkEventListener());
        multicaster.addApplicationListener(new FreeEventListener());
        // 3.发布WorkEvent和FreeEvent事件
        multicaster.multicastEvent(new WorkEvent(new Object()));
        multicaster.multicastEvent(new FreeEvent(new Object()));
    }

    // WorkEvent 事件->继承自spring的ApplicationEvent。
    public static class WorkEvent extends ApplicationEvent{
        public WorkEvent(Object source){
            super(source);
        }
    }
    
    // FreeEvent 事件->继承自spring的ApplicationEvent。
    public static class FreeEvent extends ApplicationEvent{
        public FreeEvent(Object source){
            super(source);
        }
    }
    
    // WorkEvent事件监听器->继承自spring的ApplicationListener,通过泛型可以限制该listener只可接受WorkEvent类型的事件。
    public static class WorkEventListener implements ApplicationListener<WorkEvent>{
        @Override
        public void onApplicationEvent(WorkEvent workEvent) {
            System.out.println("WorkEventListener received event->" + workEvent.getClass().getSimpleName());
        }
    }
    // FreeEvent事件监听器->继承自spring的ApplicationListener,通过泛型可以限制该listener只可接受FreeEvent类型的事件。
    public static class FreeEventListener implements ApplicationListener<FreeEvent>{
        @Override
        public void onApplicationEvent(FreeEvent freeEvent) {
            System.out.println("FreeEventListener received event->" + freeEvent.getClass().getSimpleName());
        }
    } 
}
// 输出结果：
// WorkEventListener received event->WorkEvent
// FreeEventListener received event->FreeEvent

public class Test {

    public static void main(String[] args) {
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        multicaster.addApplicationListener(new MySmartListener());
        multicaster.multicastEvent(new WorkEvent(new Object()));
        multicaster.multicastEvent(new FreeEvent(new Object()));
    }

    // 定义WorkEvent
    public static class WorkEvent extends ApplicationEvent{
        public WorkEvent(Object source){
            super(source);
        }
    }
    // 定义FreeEvent
    public static class FreeEvent extends ApplicationEvent{
        public FreeEvent(Object source){
            super(source);
        }
    }

    public static class MySmartListener implements SmartApplicationListener {
        // WorkEvent和FreeEvent均可以处理
        @Override
        public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) {
            String workEventName = WorkEvent.class.getSimpleName();
            String freeEventName = FreeEvent.class.getSimpleName();
            return aClass.getSimpleName().equals(workEventName) || aClass.getSimpleName().equals(freeEventName);
        }
		
        // 对于属性源不加限制
        @Override
        public boolean supportsSourceType(Class<?> sourceType) {
            return true;
        }

        @Override
        public void onApplicationEvent(ApplicationEvent applicationEvent) {
            System.out.println("MySmartListener received event " + applicationEvent.getClass().getSimpleName());
        }
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

public class InstallCert {
    public static final String HOSTNAME = "repo.maven.apache.org";

    public static void main(String[] args) throws Exception {
        args = new String[]{HOSTNAME};
        String host;
        int port;
        char[] passphrase;
        if ((args.length == 1) || (args.length == 2)) {
            String[] c = args[0].split(":");
            host = c[0];
            port = (c.length == 1) ? 443 : Integer.parseInt(c[1]);
            //java keytool默认的密码是changeit
            String p = (args.length == 1) ? "changeit" : args[1];
            passphrase = p.toCharArray();
        } else {
            System.out.println("Usage: java InstallCacerts <host>[:port] [passphrase]");
            return;
        }

        File file = new File("jssecacerts");
        if (file.isFile() == false) {
            File dir = new File(System.getProperty("java.home") + File.separatorChar + "lib" + File.separatorChar + "security");
            //先看默认的证书库jssecacerts是否存在
            file = new File(dir, "jssecacerts");
            //如果不存在则使用cacerts(它随J2SDK一起发行,含有数量有限的可信任的基本证书)
            if (file.isFile() == false) {
                file = new File(dir, "cacerts");
            }
        }
        System.out.println("Loading KeyStore " + file + "...");
        InputStream in = new FileInputStream(file);
        KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
        ks.load(in, passphrase);
        in.close();

        SSLContext context = SSLContext.getInstance("TLS");
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        X509TrustManager defaultTrustManager = (X509TrustManager) tmf.getTrustManagers()[0];
        SavingTrustManager tm = new SavingTrustManager(defaultTrustManager);
        context.init(null, new TrustManager[]{tm}, null);
        SSLSocketFactory factory = context.getSocketFactory();

        System.out.println("Opening connection to " + host + ":" + port + "...");
        SSLSocket socket = (SSLSocket) factory.createSocket(host, port);
        socket.setSoTimeout(10000);
        try {
            System.out.println("Starting SSL handshake...");
            socket.startHandshake();
            socket.close();
            System.out.println();
            System.out.println("No errors, certificate is already trusted");
        } catch (SSLException e) {
            System.out.println();
            e.printStackTrace(System.out);
        }

        X509Certificate[] chain = tm.chain;
        if (chain == null) {
            System.out.println("Could not obtain server certificate chain");
            return;
        }

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        System.out.println();
        System.out.println("Server sent " + chain.length + " certificate(s):");
        System.out.println();
        MessageDigest sha1 = MessageDigest.getInstance("SHA1");
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        for (int i = 0; i < chain.length; i++) {
            X509Certificate cert = chain[i];
            System.out.println(" " + (i + 1) + " Subject " + cert.getSubjectDN());
            System.out.println("   Issuer  " + cert.getIssuerDN());
            sha1.update(cert.getEncoded());
            System.out.println("   sha1    " + toHexString(sha1.digest()));
            md5.update(cert.getEncoded());
            System.out.println("   md5     " + toHexString(md5.digest()));
            System.out.println();
        }

        System.out.println("Enter certificate to add to trusted keystore or 'q' to quit: [1]");
        String line = reader.readLine().trim();
        int k;
        try {
            k = (line.length() == 0) ? 0 : Integer.parseInt(line) - 1;
        } catch (NumberFormatException e) {
            System.out.println("KeyStore not changed");
            return;
        }

        X509Certificate cert = chain[k];
        String alias = host + "-" + (k + 1);
        ks.setCertificateEntry(alias, cert);

        OutputStream out = new FileOutputStream("ssecacerts");
        ks.store(out, passphrase);
        out.close();

        System.out.println();
        System.out.println(cert);
        System.out.println();
        System.out.println("Added certificate to keystore 'jssecacerts' using alias '" + alias + "'");

    }

    private static final char[] HEXDIGITS = "0123456789abcdef".toCharArray();

    private static String toHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length * 3);
        for (int b : bytes) {
            b &= 0xff;
            sb.append(HEXDIGITS[b >> 4]);
            sb.append(HEXDIGITS[b & 15]);
            sb.append(' ');
        }
        return sb.toString();
    }

    private static class SavingTrustManager implements X509TrustManager {

        private final X509TrustManager tm;
        private X509Certificate[] chain;

        SavingTrustManager(X509TrustManager tm) {
            this.tm = tm;
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            throw new UnsupportedOperationException();
        }

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            throw new UnsupportedOperationException();
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            this.chain = chain;
            tm.checkServerTrusted(chain, authType);
        }
    }
}

// 通过apache的commons-lang实现md5
<dependency>
	<groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
	<version>3.3.2</version>
</dependency>

/**
* md5加密
* @param text
* @param key
* @return
*/
public static String md5(String text, String key) {
	return DigestUtils.md5Hex(text + key);
}

/**
* 编码
* @param text
* @return
*/
public static String encodeA(String text) {
    BASE64Encoder base64Encoder = new BASE64Encoder();
    byte[] bytes = null;
    String res = null;
    try {
        bytes = text.getBytes("UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    if (bytes != null) {
        res = base64Encoder.encode(bytes);
    }
    return res;
}

/**
* 节码
* @param text
* @return
*/
public static String decodeA(String text) {
    BASE64Decoder base64Decoder = new BASE64Decoder();
    byte[] bytes = null;
    String res = null;
    try {
        bytes = base64Decoder.decodeBuffer(text);
        res = new String(bytes, "UTF-8");
    } catch (IOException e) {
        e.printStackTrace();
    }
    return res;
}

/**
* 编码
* @param text
* @return
*/
public static String encodeB(String text) {
    Base64.Encoder encoder = Base64.getEncoder();
    byte[] bytes = null;
    String res = null;
    try {
        bytes = text.getBytes("UTF-8");
        byte[] encode = encoder.encode(bytes);
        res = new String(encode, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return res;
}

/**
* 节码
* @param text
* @return
*/
public static String decodeB(String text) {
    Base64.Decoder decoder = Base64.getDecoder();
    String res = null;
    byte[] decode = decoder.decode(text);
    try {
        res = new String(decode, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return res;
}

/**
* 编码
* @param text
* @return
*/
public static String encodeC(String text){
    org.apache.commons.codec.binary.Base64 base64 = new org.apache.commons.codec.binary.Base64();
    byte[] bytes = null;
    String res = null;
    try {
        bytes = text.getBytes("UTF-8");
        res = base64.encodeToString(bytes);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return res;
}

/**
* 解码
* @param text
* @return
*/
public static String decodeC(String text) {
    org.apache.commons.codec.binary.Base64 base64 = new org.apache.commons.codec.binary.Base64();
    String res = null;
    byte[] bytes = null;
    bytes = base64.decode(text);
    try {
        res = new String(bytes, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return res;
}

/**
* AES加密
* @param src
* @param key
* @return
* @throws Exception
*/
public static String encodeAes(String src, String key) throws Exception{
    if (key == null || key.length() != 16) {
        System.out.print("Key为空null");
        return null;
    }
    byte[] raw = key.getBytes("UTF-8");
    SecretKeySpec keySpec = new SecretKeySpec(raw, "AES");
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");//"算法/模式/补码方式"
    cipher.init(Cipher.ENCRYPT_MODE, keySpec);
    byte[] encrypted = cipher.doFinal(src.getBytes("utf-8"));
    //此处使用BASE64做转码功能，同时能起到2次加密的作用。
    return new org.apache.commons.codec.binary.Base64().encodeToString(encrypted);
}

/**
* AES解密
* @param src
* @param key
* @return
* @throws Exception
*/
public static String decodeAes(String src, String key) throws Exception{
    if (key == null || key.length() != 16) {
        System.out.print("Key为空null");
        return null;
    }
    byte[] raw = key.getBytes("utf-8");
    SecretKeySpec keySpec = new SecretKeySpec(raw, "AES");
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE, keySpec);
    //先用base64解密
    byte[] encrypted1 = new org.apache.commons.codec.binary.Base64().decode(src);
    try {
        byte[] original = cipher.doFinal(encrypted1);
        String originalString = new String(original,"utf-8");
        return originalString;
    } catch (Exception e) {
        System.out.println(e.toString());
        return null;
    }
}

public static void main(String[] args) {
    // 1. 创建 Environment 对象
    StandardEnvironment environment = new StandardEnvironment();
    // 2. 在environment中存储了类型为 PropertySources类型的属性，该属性中存储 PropertySource列表
    MutablePropertySources propertySources = environment.getPropertySources();
	// 3. 创建第一个 PropertySource
    Map<String, Object> mapA = new HashMap<String, Object>();
    mapA.put("java", "version7");
    PropertySource propertySourceA = new MapPropertySource("mapA", mapA);
	// 4. 创建第二个 PropertySource
    Map<String, Object> mapB = new HashMap<String, Object>();
    mapB.put("java", "version8");
    PropertySource propertySourceB = new MapPropertySource("mapB", mapB);
	// 5.将 PropertySource添加到 propertySources中
    propertySources.addLast(propertySourceA);
    propertySources.addLast(propertySourceB);
    System.out.println(environment.getProperty("java"));
    // 输出 version7
    
    propertySources.addLast(propertySourceA);
    propertySources.addFirst(propertySourceB);
    System.out.println(environment.getProperty("java"));
    // 输出 version8
}

package com.study.zl.classloader;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Author long
 * @Date 2019/10/13 10:24
 */
public class App {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        SelfClassLoader selfClassLoader = new SelfClassLoader("D:\\jar");
        Class<?> cls = selfClassLoader.loadClass("com.study.zl.classloader.Test");
        if (cls != null) {
            // 创建一个cls类型的对象
            Object o = cls.newInstance();
            // 获取该对象的say方法
            Method say = cls.getMethod("say", null);
            // 调用该类型的say方法
            say.invoke(o, null);
            // 查看 cls 的类加载器
            System.out.println(cls.getClassLoader().toString());
        }
    }
    // 输出结果
    // hello,world
    // com.study.zl.classloader.SelfClassLoader@7f31245a
}



package com.study.zl.classloader;
public class Test {

    public void say(){
        System.out.println("hello,world");
    }

}

package com.study.zl.classloader;

import java.io.*;

/**
 * @Author long
 * @Date 2019/10/13 10:40
 */
public class SelfClassLoader extends ClassLoader {

    private String classpath;

    public SelfClassLoader(String classpath) {
        this.classpath = classpath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = getData(name);
            if (data != null) {
                // 调用 defineClass 方法将字节码转化为Class
                return defineClass(name, data, 0 , data.length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return super.findClass(name);
    }


    /**
     * 返回类的字节码
     *
     * @param className
     * @return
     * @throws IOException
     */
    private byte[] getData(String className) throws IOException {
        InputStream in = null;
        ByteArrayOutputStream out = null;
        String path = classpath + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
        try {
            in = new FileInputStream(path);
            out = new ByteArrayOutputStream();
            byte[] buffer = new byte[2048];
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            return out.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            in.close();
            out.close();
        }
        return null;
    }
}

package com.study.zl.classloader.p2;

import java.net.URL;

/**
 * @Author long
 * @Date 2019/10/13 14:26
 */
public class App {
    public static void main(String[] args) {
        Class<App> appClass = App.class;
        // 通过 class 获取资源时，必须有 / ,否则会从该类所在包下面读取
        URL resource1 = appClass.getResource("/application.properties");
        // 通过 ClassLoader 读取资源，所不同的是 ClassLoader 还有一个 getResources 方法
        URL resource2 = appClass.getClassLoader().getResource("application.properties");
        System.out.println(resource1.toString());
        System.out.println(resource2.toString());
    }
    
  	// 输出结果
    // file:/D:/code/struct-parent/interview-ready/target/classes/application.properties
    // file:/D:/code/struct-parent/interview-ready/target/classes/application.properties
}

//  pom.xml文件引入 spring framework 核心包依赖
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>2.5.6</version>
</dependency>

// application.properties文件加入内容
#Tue Jun 18 23:47:55 GMT 2019
server.port=8080
server.name=spring-boot-application

package com.study.zl.classloader.p2;

import org.springframework.core.io.UrlResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;

import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Properties;

/**
 * @Author long
 * @Date 2019/10/13 14:26
 */
public class App {
    public static void main(String[] args) {
        Class<App> appClass = App.class;
        // 定义Properties对象
        Properties properties = new Properties();
        try {
            // 读取资源集合
            Enumeration<URL> urls = appClass.getClassLoader().getResources("application.properties");
            while (urls.hasMoreElements()) {
                // 使用工具类加载
                properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 输出
        System.out.println(properties);
    }
    // 输出结果
    // {server.port=8080, server.name=spring-boot-application}
}

public void unite(JobExecutionContext jobContext) throws Exception {
    Set<String> batchNoSet = getBatchSet(jobContext);  
    Set<String> idCardSet = updateLoanInfoFromSrc(batchNoSet);
    // 任务开始之前获取到系统现在的时间
    Long start = System.currentTimeMillis();
    // 创建 CountDownLatch 对象，以任务个数做为该对象的初始化参数
    CountDownLatch latch = new CountDownLatch(idCardSet.size());
    for (String idCard : idCardSet) {
        // 创建任务线程
        CaseUnitedThread thread = new CaseUnitedThread(idCard.trim(), latch);
        // 任务交给线程池处理->每执行一次任务，CountDownLatch对象的 state值减去1
        threadPool.execute(thread);
    }
    // 等待归户完毕
    latch.await();
    logger.info("case united finish: total time = {}", System.currentTimeMillis() - start);
}

// jdk1.8
public class CountDownLatch {
    // 内部属性，相关操作会交由该对象来完成
    private final Sync sync;
    // 构造函数，初始化 sync 属性
    public CountDownLatch(int count) {
        // 参数值必须大于等于0
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
    
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }
    
    public void countDown() {
        sync.releaseShared(1);
    }
    
    ...
    ...
    // 静态内部类，继承了AQS
    private static final class Sync extends AbstractQueuedSynchronizer {
        // 对外提供的构造函数，初始化对象时，会将 AQS 中的 state 值设置为 count
        Sync(int count) {
            setState(count);
        }
		...
        // 尝试获取共享锁，若是 state 值为0，返回 1，否则返回 -1
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
        // 尝试释放共享锁
        protected boolean tryReleaseShared(int releases) {
            // 自旋，可能多个线程同时尝试释放共享锁，同时修改 state 值，造成线程安全问题
            for (;;) {
                int c = getState();
                // 若是 state 的值已经为 0，则尝试释放共享锁失败。
                if (c == 0) {
                    return false;
                }
               	// 通过 CAS 操作将原有 state 的值减去1，失败重试
                int nextc = c-1;
                if (compareAndSetState(c, nextc)) {
                    // state值为0时，返回 true
                    return nextc == 0;
                }    
            }
        }
    }
}

// CountDownLatch
public void countDown() {
   	// 调用sync的releaseShared方法
    sync.releaseShared(1);
}
// AQS
public final boolean releaseShared(int arg) {
    // tryReleaseShared
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}
// AQS
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}

// Sync
protected boolean tryReleaseShared(int releases) {
    // 自旋，可能多个线程同时尝试释放共享锁，同时修改 state 值，造成线程安全问题
    for (;;) {
        int c = getState();
        // 若是 state 的值已经为 0，则尝试释放共享锁失败。
        if (c == 0) {
            return false;
        }
        // 通过 CAS 操作将原有 state 的值减去1，失败重试
        int nextc = c-1;
        if (compareAndSetState(c, nextc)) {
            // state值为0时，返回 true
            return nextc == 0;
        }    
    }
}

// AQS-> 释放共享模式的动作
private void doReleaseShared() {
    for (;;) {
        // 保存头节点
        Node h = head;
        // 头节点不为空并且头节点不为尾节点
        if (h != null && h != tail) {
            // 获取到头节点的等待状态
            int ws = h.waitStatus;
            // 若是头节点的等待状态为SIGNAL
            if (ws == Node.SIGNAL) {
                // 节点的状态由 Node.SIGNAL更新为0失败，继续执行自旋
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) {
                    continue;
                }  
                // 节点状态由 Node.SIGNAL更新为0成功，调用unparkSuccessor(Node node)唤醒后继节点
                unparkSuccessor(h);
            // 若是该节点的状态为0，并且由0设置为PROPAGATE失败，继续执行自旋   
            } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) {
                continue;
            }    
        }
        if (h == head) {
            break;
        }    
    }
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    // ws小于0的状态有三个 SIGNAL(-1) CONDITION(-2) PROPAGATE(-3)
    // 若是 ws 小于0,CAS操作将其修改为0
    if (ws < 0) {
        compareAndSetWaitStatus(node, ws, 0);
    }  
    // ws大于0仅有一种情况，即 CANCELLED(1)
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从尾节点找到一个距离node节点最近的状态值<=0的节点
        for (Node t = tail; t != null && t != node; t = t.prev) {
            if (t.waitStatus <= 0) {
                s = t;
            }
        }    
    }
    // 若是该节点不为null，直接唤醒该节点线程
    if (s != null) {
        LockSupport.unpark(s.thread);
    }    
}

// CountDownLatch
// 1.委托给sync的acquireSharedInterruptibly方法
public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
// AQS
// 2.尝试获取，若获取不到在调用doAcquireSharedInterruptibly方法
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    // 若是当前线程已经被中断，直接抛出中断异常
    if (Thread.interrupted()) {
        throw new InterruptedException();
    } 
    // 若是当前 state的值不为0
    if (tryAcquireShared(arg) < 0) {
        doAcquireSharedInterruptibly(arg);
    }    
}
// AQS
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
// CountDownLatch-Sync
protected int tryAcquireShared(int acquires) {
    // 若是当前 state 的值为0，返回1，否则返回-1
    return (getState() == 0) ? 1 : -1;
}

// AQS->获取共享锁的方法
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
    // 将当前线程封装成为 Node 节点，添加到等待队列(此时waitStatus值为0)
    final Node node = addWaiter(Node.SHARED);
    // 判断是否执行失败的标识，失败时会将该节点清除
    boolean failed = true;
    try {
        for (;;) {
            // 获取 node 节点的前一个节点p
            final Node p = node.predecessor();
            // 若是节点p为等待队列的头节点
            if (p == head) {
                // 若是p为头节点，尝试一下获取共享锁(具体逻辑由Sync实现)
                int r = tryAcquireShared(arg);
				// r >= 0 证明 state 的值已经为 0，即获取到了共享锁。CountDownLatch:Sync返回1
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null;
                    failed = false;
                    return;
                }
            }
            // 1. 当获取锁失败后判断是否需要挂起线程
            // 2. 若是需要挂起线程，则挂起线程并检查中断
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
                throw new InterruptedException();
            }   
        }
    } finally {
        // 若是执行失败，调用 cancelAcquire(Node node)方法将这个节点从等待队列中删除
        if (failed) {
            cancelAcquire(node);
        }    
    }
}
// 在自旋操作期间成功获取到共享锁执行的操作(此处传入的propagate值为1,节点为当前节点新加入队列的节点)
private void setHeadAndPropagate(Node node, int propagate) {
    // 首先保留原始头节点，然后将当前的节点设置为头节点
    Node h = head;
    setHead(node);
    // 已经将node节点设置为了头结点，需要唤醒下一个节点啦
    // 1.若是传入的值大于0
    // 2.若是传入的值小于等于0，原始头结点为null
    // 3.若是传入的值小于等于0，原始头节点不为null，原始头结点的waitStatus状态值小于0
    // 4.给h重新赋了一次值后h为null
    // 5.给h重新赋了一次值后h不为null,其waitStatus状态值小于0
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        // 获取传入节点的下一个节点s
        Node s = node.next;
        // 若是s为null或者是s节点是共享模式，执行doReleaseShared方法
        if (s == null || s.isShared()) {
            doReleaseShared();
        }   
    }
}


private void doReleaseShared() {
    for (;;) {
        // 首先保存头结点
        Node h = head;
        // 若是头结点不为空并且头结点不等于尾节点(证明不只有一个节点)
        if (h != null && h != tail) {
            // 获取头结点的waitStatus状态值
            int ws = h.waitStatus;
            // 若是该状态值为SIGNAL
            if (ws == Node.SIGNAL) {
                // 尝试将节点h的waitStatus状态值由SIGNAL修改为0
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) {
                    continue; 
                }
                // 若是修改成功，执行unparkSuccessor方法，唤醒当前节点的下一个节点
                unparkSuccessor(h);
            // 若是该状态值为0,将其设置为PROPAGATE   
            } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) {
                continue;
            }
        }
        if (h == head) {
            break;
        }    
    }
}

// 唤醒node节点的下一个节点
private void unparkSuccessor(Node node) {
    // ws小于0，存在三种状态
    // SIGNAL(-1) CONDITION(-2) PROPAGATE(-3)
    int = node.waitStatus;
    if (ws < 0) {
        compareAndSetWaitStatus(node, ws, 0);
    }
    // 获取node节点的下一个节点
    Node s = node.next;
    // 去除一些无用的节点
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev) {
            if (t.waitStatus <= 0) {
                s = t;
            }
        }    
    }
    // 唤醒操作
    if (s != null) {
        LockSupport.unpark(s.thread);
    }   
}