package xyz.kail.demo.java.se.temp;

import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class HttpClientMain {


    public static void main(String[] args) throws IOException, InterruptedException {

        int count = 20;

        CountDownLatch countDownLatch = new CountDownLatch(count);

        CloseableHttpClient httpClient = HttpClients.createDefault();

        ExecutorService executorService = Executors.newFixedThreadPool(count);

        for (int i = 0; i < count; i++) {

            executorService.submit(() -> {
                countDownLatch.countDown(); // line num: 32
                try {
                    request(httpClient);
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            });

        }

        countDownLatch.await();  // line num: 42
        System.out.println("countDownLatch.await();");

        httpClient.close();  // line num: 45
        System.out.println("httpClient.close();");

        executorService.shutdown();
        System.out.println("executorService.shutdown();");


    }

    private static void request(CloseableHttpClient client) throws IOException, InterruptedException {

        HttpGet request = new HttpGet("http://blog.kail.xyz");
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(1_000)
                .setSocketTimeout(5_000)
                .build();

        request.setConfig(requestConfig);
        try (CloseableHttpResponse response = client.execute(request)) { // line num: 63
            String data = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
        } finally {
            request.releaseConnection();
        }
    }
}

package java.lang;

...

public class Thread implements Runnable {

 ...

   public enum State {
        /**
         * 新创建了一个线程对象，但还没有调用start()方法
         */
        NEW,

        /**
         * Thead.start
         */
        RUNNABLE,

        /**
         * 等待/阻塞 获取 synchronized 锁
         */
        BLOCKED,

        /**
         * Object.wait / Thread.join / LockSupport.park 未设置超时时间
         */
        WAITING,

        /**
         * 以下的几种情况
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         */
        TIMED_WAITING,

        /**
         * 线程已经执行完成
         */
        TERMINATED;
    }
}

// 入口
// xyz.kail.demo.java.se.temp.HttpClientMain.request(HttpClientMain.java:63)
// at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:108)
private E getPoolEntryBlocking(...){
        ...
        this.lock.lock();
        try {
            ...
                    } else {
...                     // 5️⃣ 线程2 wait，但是这时候线程1已经 BLOCKED
                        this.condition.await(); // line num: 377 [WAITING (parking)]
                        success = true;
                    }
            ...
        } finally {
            this.lock.unlock();
        }
    }
}

@Override
public Future<E> lease(final T route, final Object state, final FutureCallback<E> callback) {
   
...

    return new Future<E>() {

...
        // 入口
        // at xyz.kail.demo.java.se.temp.HttpClientMain.main(HttpClientMain.java:45)
        // at org.apache.http.impl.client.InternalHttpClient.close(InternalHttpClient.java:201)
        @Override
        public boolean cancel(final boolean mayInterruptIfRunning) {
            cancelled = true;
            lock.lock();
            try {
                condition.signalAll(); // 1️⃣ 线程1
            } finally {
                lock.unlock();
            }
            // 3️⃣ 线程1 这时候线程2已经获取到锁，这里 BLOCKED
            synchronized (this) { // line num 207 BLOCKED (on object monitor)
...
            }
        }

...

        @Override
        public E get(final long timeout, final TimeUnit tunit) throws InterruptedException, ExecutionException, TimeoutException {
...
            synchronized (this) { // 2️⃣ 线程2 获取锁
...                     // 4️⃣ 线程2 执行 getPoolEntryBlocking 方法
                        final E leasedEntry = getPoolEntryBlocking(...); // 调用 377 行的代码
...
            }
        }

    };
}