最近发现synchronized锁的是什么？甚至有人认为synchronized锁的是代码？？！这个我觉得还是很有必要通过实际的示例来说明synchronized锁的到底是什么。

**根据获取的锁的分类：获取对象锁和获取类锁！**

> **获取对象锁的两种用法**

1、同步代码块(synchronized(this), synchronized(类实例对象))，锁是小括号()中的实例对象。
2、同步非静态方法(synchronized method)，锁是当前对象的实例对象。

> **获取类锁的两种用法**

1、同步代码块(synchronized(类.class))，锁是小括号()中的类对象，即Class对象。
2、同步静态方法(synchronized static method)，锁是当前对象的类对象(Class对象)。



## 对象锁示例

看看这样一段代码：

SynchronizedDemo.java

```java
package thread_study.synchronize;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizedDemo implements Runnable{

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if(threadName.startsWith("A")){
            async();
        }else if(threadName.startsWith("B")){
            syncObjectBlock();
        }else if(threadName.startsWith("C")){
            syncObjectMethod();
        }
    }

    private void async() {
        try {
            System.out.println(Thread.currentThread().getName()
            + "_Async_Start:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
            TimeUnit.SECONDS.sleep(1);
            
            System.out.println(Thread.currentThread().getName() 
            + "_Async_End:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private synchronized void syncObjectMethod() {
        System.out.println(Thread.currentThread().getName() 
        + "_SyncObjectMethod:" 
        + new SimpleDateFormat("mm:ss").format(new Date()));
        
        try {
            System.out.println(Thread.currentThread().getName() 
            + "_SyncObjectMethod_Start:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
            TimeUnit.SECONDS.sleep(1);
            
            System.out.println(Thread.currentThread().getName() 
            + "_SyncObjectMethod_End:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void syncObjectBlock() {
        System.out.println(Thread.currentThread().getName() 
        + "_SyncObjectBlock:" 
        + new SimpleDateFormat("mm:ss").format(new Date()));
        synchronized (this){
            try {
                System.out.println(Thread.currentThread().getName() 
                + "_SyncObjectBlock_Start:" 
                + new SimpleDateFormat("mm:ss").format(new Date()));
                
                TimeUnit.SECONDS.sleep(1);
                
                System.out.println(Thread.currentThread().getName() 
                + "_SyncObjectBlock_End:" 
                + new SimpleDateFormat("mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```

SynchronizedMain.java

```java
package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        Thread A_thread1 = new Thread(demo, "A_thread1");
        Thread A_thread2 = new Thread(demo, "A_thread2");
        Thread B_thread1 = new Thread(demo, "B_thread1");
        Thread B_thread2 = new Thread(demo, "B_thread2");
        Thread C_thread1 = new Thread(demo, "C_thread1");
        Thread C_thread2 = new Thread(demo, "C_thread2");
        A_thread1.start();
        A_thread2.start();

        B_thread1.start();
        B_thread2.start();

        C_thread1.start();
        C_thread2.start();
    }
}
```

![mark](https://img.zouchanglin.cn///20200328/u7YzUcztNnC7.png)

但是如果我们传入不同的对象呢？

```java
package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        //SynchronizedDemo demo = new SynchronizedDemo();
        Thread A_thread1 = new Thread(new SynchronizedDemo(), "A_thread1");
        Thread A_thread2 = new Thread(new SynchronizedDemo(), "A_thread2");
        Thread B_thread1 = new Thread(new SynchronizedDemo(), "B_thread1");
        Thread B_thread2 = new Thread(new SynchronizedDemo(), "B_thread2");
        Thread C_thread1 = new Thread(new SynchronizedDemo(), "C_thread1");
        Thread C_thread2 = new Thread(new SynchronizedDemo(), "C_thread2");
        A_thread1.start();
        A_thread2.start();

        B_thread1.start();
        B_thread2.start();

        C_thread1.start();
        C_thread2.start();
    }
}
```



![mark](https://img.zouchanglin.cn///20200328/yYIgVyzq230d.png)

从上面的代码和结果中我们可以得出一个结论，那就是

获取对象锁的两种用法：
1、同步代码块(synchronized(this), synchronized(类实例对象))，锁是小括号()中的实例对象。
2、同步非静态方法(synchronized method)，锁是当前对象的实例对象。

> 同步非静态方法锁住整个方法，而同步代码块只是锁住的只是方法中的一部分代码

获取类锁的两种用法
1、同步代码块(synchronized(类.class))，锁是小括号()中的类对象，即Class对象。
2、同步静态方法(synchronized static method)，锁是当前对象的类对象(Class对象)。

> 同步静态方法锁住整个方法，而同步代码块只是锁住的只是方法中的一部分代码，与上面一样的

## 类锁示例

下面来看看同步静态方法和同步代码块(synchronized(类.class))的效果吧：

```java
package thread_study.synchronize;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizedDemo implements Runnable{

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if(threadName.startsWith("A")){
            async();
        }else if(threadName.startsWith("B")){
            syncObjectBlock();
        }else if(threadName.startsWith("C")){
            syncObjectMethod();
        }else if(threadName.startsWith("D")){
            syncClassBlock();
        }else if(threadName.startsWith("E")){
            syncClassMethod();
        }
    }

    private synchronized static void syncClassMethod() {
        System.out.println(Thread.currentThread().getName()
                           + "_SyncClassMethod:"
                           + new SimpleDateFormat("mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName()
                               + "_SyncClassMethod_Start:"
                               + new SimpleDateFormat("mm:ss").format(new Date()));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName()
                               + "_SyncClassMethod_End:"
                               + new SimpleDateFormat("mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void syncClassBlock() {
        System.out.println(Thread.currentThread().getName()
                           + "_SyncClassBlock:" 
                           + new SimpleDateFormat("mm:ss").format(new Date()));
        synchronized (SynchronizedDemo.class){
            try {
                System.out.println(Thread.currentThread().getName()
                                   + "_SyncClassBlock_Start:"
                                   + new SimpleDateFormat("mm:ss").format(new Date()));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName()
                                   + "_SyncClassBlock_End:" 
                                   + new SimpleDateFormat("mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void async() {
        try {
            System.out.println(Thread.currentThread().getName() 
                               + "_Async_Start:" 
                               + new SimpleDateFormat("mm:ss").format(new Date()));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() 
                               + "_Async_End:" 
                               + new SimpleDateFormat("mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //...和上面一样的
}
```

SynchronizedMain.java

```java
package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        Thread A_thread1 = new Thread(new SynchronizedDemo(), "A_thread1");
        Thread A_thread2 = new Thread(new SynchronizedDemo(), "A_thread2");
        Thread D_thread1 = new Thread(new SynchronizedDemo(), "D_thread1");
        Thread D_thread2 = new Thread(new SynchronizedDemo(), "D_thread2");
        Thread E_thread1 = new Thread(new SynchronizedDemo(), "E_thread1");
        Thread E_thread2 = new Thread(new SynchronizedDemo(), "E_thread2");

        A_thread1.start();
        A_thread2.start();

        D_thread1.start();
        D_thread2.start();
        E_thread1.start();
        E_thread2.start();
    }
}
```

![mark](https://img.zouchanglin.cn///20200328/cqqOH3HC0DTl.png)

## 对象锁和类锁不会干扰

最后看看类锁和对象锁是否会相互影响呢？

修改一下代码：

```java
package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        //SynchronizedDemo demo = new SynchronizedDemo();
        Thread A_thread1 = new Thread(new SynchronizedDemo(), "A_thread1");
        Thread A_thread2 = new Thread(new SynchronizedDemo(), "A_thread2");
        Thread B_thread1 = new Thread(new SynchronizedDemo(), "B_thread1");
        Thread B_thread2 = new Thread(new SynchronizedDemo(), "B_thread2");
        Thread C_thread1 = new Thread(new SynchronizedDemo(), "C_thread1");
        Thread C_thread2 = new Thread(new SynchronizedDemo(), "C_thread2");
        Thread D_thread1 = new Thread(new SynchronizedDemo(), "D_thread1");
        Thread D_thread2 = new Thread(new SynchronizedDemo(), "D_thread2");
        Thread E_thread1 = new Thread(new SynchronizedDemo(), "E_thread1");
        Thread E_thread2 = new Thread(new SynchronizedDemo(), "E_thread2");

        A_thread1.start();
        A_thread2.start();

        B_thread1.start();
        B_thread2.start();
        C_thread1.start();
        C_thread2.start();

        D_thread1.start();
        D_thread2.start();
        E_thread1.start();
        E_thread2.start();
    }
}
```

![mark](https://img.zouchanglin.cn///20200328/Iyib50dWpIpK.png)

可以看出来，类锁和对象锁是不会相互干扰的！

synchronized锁的是什么

![mark](https://img.zouchanglin.cn///20200324/n0eEP9zdhKzQ.png)

本文主要讲述了进程和线程发展简史，对于JVM来讲的进程和线程又是什么，Thread的start()方法的原生调用发生了什么，从而理解start()方法和run()方法有什么不同，另外，还介绍了三种处理线程执行完成后的返回值的方法，其实FutureTask和线程池获取线程执行结束的返回值更加常用。另外，介绍了线程的六种状态，还有sleep和wait的区别，notify和notifyAll的区别，yield函数的作用，以及如何优雅的中断线程等问题。



# 关于进程和线程

* 串行：初期的计算机只能串行执行任务，并且需要长时间等待用户输入
* 批处理：预先将用户的指令集中成清单，批量串行处理用户指令，仍然无法并发执行
* 进程：进程独占内存空间，保存各自运行状态，相互间不干扰且可以互相切换，为并发处理任务提供了可能
* 线程：共享进程的内存资源，相互间切换更快速，支持更细粒度的任务控制，使进程内的子任务得以并发执行

**进程是资源分配的最小单位，线程是CPU调度的最小单位**
所有与进程相关的资源，都被记录在PCB中，进程是抢占处理机的调度单位；线程属于某个进程，共享其资源。线程只由堆栈寄存器、程序计数器和TCB组成。

线程不能看做独立应用，而进程可看做独立应用；进程有独立的地址空间，相互不影响，线程只是进程的不同执行路径；线程没有独立的地址空间，多进程的程序比多线程程序健壮。进程的切换比线程的切换开销大。

# Java进程和线程的关系

Java对操作系统提供的功能进行封装，包括进程和线程。运行一个程序会产生一个进程，进程包含至少一个线程。每个进程对应一个JVM实例，多个线程共享JVM里的堆，Java采用单线程编程模型，程序会自动创建主线程，主线程可以创建子线程，原则上要后于子线程完成执行。

# Thread中的start和run方法的区别
调用start()方法会创建一个新的子线程并启动，run()方法只是Thread的一个普通方法的调用。

```java
public class ThreadTest {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()); //main
        }).run(); 

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()); //Thread-1
        }).start();
    }
}
```

start()点进去其实调用了start0()，而start0()是一个native方法，通过查看源码我们得知：

![mark](https://img.zouchanglin.cn///20200323/tkItI4FKXPsO.png)

其实调用start0()，在底层就是创建了一个线程并且让新的线程执行这个run方法

# 处理线程返回值

1、主线程等待法

这个方法比较简单，但是需要自己实现循环等待的逻辑：
```java
package thread_study;

import java.util.concurrent.TimeUnit;

public class CycleWait implements Runnable {
    private String value;
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.value = "Hello Thread";
    }

    public static void main(String[] args) throws InterruptedException {
        CycleWait cycleWait = new CycleWait();
        Thread thread = new Thread(cycleWait);
        thread.start();
        while(cycleWait.value == null){
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(cycleWait.value);
    }
}
```

2、使用Thread类的join()阻塞当前线程以等待子线程处理完毕，能够实现比我们自己循环等到更为精细的控制

```java
package thread_study;

import java.util.concurrent.TimeUnit;

public class JoinWait implements Runnable {
    private String value;
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.value = "Hello Thread";
    }

    public static void main(String[] args) throws InterruptedException {
        JoinWait cycleWait = new JoinWait();
        Thread thread = new Thread(cycleWait);
        thread.start();
        thread.join();
        System.out.println(cycleWait.value);
    }
}
```

3、通过Callable接口实现：通过FutureTask Or 线程池获取
在JDK5之前，线程是没有返回值的，通常为了能够获取线程的返回值而颇费周折

> **1、通过FutureTask来完成**

MyCallable.java

```java
import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("Ready to work");
        Thread.sleep(5000);
        System.out.println("Task done");
        return value;
    }
}
```

FutureTaskDemo.java

```java
package thread_study;

import java.util.concurrent.FutureTask;

public class FutureTaskDemo {
    public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        if(!futureTask.isDone()){
            System.out.println("Task is not finished, please wait!");
        }
        System.out.println("task return: " + futureTask.get());
    }
}
```

> **2、通过线程池来完成**

还是依旧沿用MyCallable.java的代码，下面是ThreePoolDemo.java

```java
package thread_study;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreePoolDemo {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        Future<String> futureTask = cachedThreadPool.submit(new MyCallable());
        if(!futureTask.isDone()){
            System.out.println("Task is not finished, please wait!");
        }
        try {
            System.out.println(futureTask.get());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            cachedThreadPool.shutdown();
        }
    }
}
```

# 线程的六种状态

* 新建(New)：创建后尚未启动的线程的状态。
* 运行(Runnable)：包含Running和Ready。
* 无限期等待(Waiting)：不会被分配CPU执行时间，需要显式被唤醒
	* 没有设置Timeout参数的0bject.wait()方法。
	* 没有设置Timeout参数的Thread.join()方法。
	* LockSupport.park()方法。
* 限期等待(Timed Waiting)：在一定时间后会由系统自动唤醒
	* Thread.sleep()方法。
	* 设置了Timeout参数的0bject.wait()方法。
	* 设置了Timeout参数的Thread.join()方法。
	* LockSupport.parkNanos()方法。
	* LockSupport.parkUntil()方法。
* 阻塞(Blocked)：等待获取排它锁
* 结束(Terminated)：已终止线程的状态，线程已经结束执行

那么等待和阻塞式什么关系呢？不都是停下来吗？其实两者都表示线程当前暂停执行的状态，而两者的区别，基本可以理解为：进入 waiting 状态是线程主动的，而进入 blocked 状态是被动的。更进一步的说，进入 blocked 状态是在同步（synchronized）代码之外，而进入 waiting 状态是在同步代码之内（然后马上退出同步）。

![mark](https://img.zouchanglin.cn///20200324/n0eEP9zdhKzQ.png)

# sleep与wait

sleep和wait最主要的本质区别：Thread.sleep只会让出CPU，不会导致锁行为的改变；Object.wait不仅让出CPU，还会释放已经占有的同步资源锁。这也就是wait必须写在synchronized里面的原因，因为我只有获取到锁了，我才可能释放锁嘛。

# notify与notifyAll

锁池EntryList：

假设线程A已经拥有了某个对象(不是类)的锁，而其它线程B、C想要调用这个对象的某个synchronized方法(或者块)，由于B、C线程在进入对象的synchronized方法(或者块)之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池

等待池WaitSet：

假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程，不会去竞争该对象的锁。

notify和notifyAll的区别：

* notifyAll 会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会
* notify只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会。



# yield的使用

```java
public class YieldDemo {
    public static void main(String[] args) {
        Runnable runnable = () -> {
            for (int i = 0; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
                if(i == 5){
                    Thread.yield();
                }
            }
        };
        new Thread(runnable, "A").start();
        new Thread(runnable, "B").start();
    }
}
```

![mark](https://img.zouchanglin.cn///20200324/aDLBuxynva93.png)

从运行结果来看，yield会让当前线程放弃CPU执行权，让给其他的线程，但是这也是不可控的，调用此方法可能没效果，比如下面这样：

![mark](https://img.zouchanglin.cn///20200324/T3EkjxojuCey.png)

需要注意的是yield不会使当前线程放弃持有的锁

# 优雅地中断线程 interrupt

已经被弃用的方法：stop()，这个方法不仅暴力，而且不安全， 可能使一些清理性的工作得不到完成。还可能对锁定的内容进行解锁，容易造成数据不同步的问题。 



使用interrupt方法中断线程：调用interrupt()，即是通知线程应该中断了
①如果线程处于被阻塞状态，那么线程将立即退出被阻塞状态，并抛出一个InterruptedException异常。
②如果线程处于正常活动状态，那么会将该线程的中断标志设置为true。被设置中断标志的线程将继续正常运行,不受影响。

需要被调用的线程配合中断
①在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程。
②如果线程处于正常活动状态，那么会将该线程的中断标志设置为true。被设置中断标志的线程将继续正常运行,不受影响。

```java
package thread_study;

public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Runnable task = ()->{
            int i = 0;
            try{
                while (!Thread.currentThread().isInterrupted()){
                    Thread.sleep(100);
                    i++;
                    System.out.println(Thread.currentThread().getName() + " (" +
                            Thread.currentThread().getState()+") loop " + i);
                }
            }catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName() + " (" +
                        Thread.currentThread().getState()+") catch InterruptedException");
            }
        };

        Thread t1 = new Thread(task, "T1");
        System.out.println(t1.getName() + " (" + t1.getState() + ") is new.");

        t1.start();
        System.out.println(t1.getName() + " (" + t1.getState() + ") is started.");

        Thread.sleep(300);
        t1.interrupt();
        System.out.println(t1.getName() + " (" + t1.getState() + ") is interrupted.");

        Thread.sleep(300);
        System.out.println(t1.getName() + " (" + t1.getState() + ") is interrupted now.");
    }
}
```

![mark](https://img.zouchanglin.cn///20200325/5yCcEEYtoF7d.png)

线程相关的基础问题

![mark](https://img.zouchanglin.cn///20200322/4XcsC1Ht6x4l.png)

OkHttp是一个优秀的网络请求框架，我开始接触Android开发的时候就用过这个网络请求框架，官方的参考文档在这里  https://square.github.io/okhttp/ ，本文演示了使用OkHttp框架进行简单的Get、Post（表单形式和JSON形式）、Delete、附加请求头、请求异步回调，文件的上传和下载等常用操作。最后记录了一个今天调试了很久的坑，那就是response.body().string()只能有效调用一次，注意Debug的时候对结果造成的改变！JDK9的HttpURLConnection有很多变化，下次博客中会有演示和说明。



首选引入这个依赖就可以使用OkHTTP了

```xml
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.6.0</version>
</dependency>


<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>
```

如果是 gradle 管理的项目，则只需要引入：

```groovy
compile 'com.squareup.okhttp3:okhttp:3.6.0'
```



# 1、Get请求示例

```java
String url = "http://zouchanglin.cn";
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder().get().url(url).build();
try {
    Response execute = okHttpClient.newCall(request).execute();
    System.out.println(execute.body().string());
} catch (IOException e) {
    e.printStackTrace();
}
```

# 2、Post请求示例

1、JSON请求

```java
public static void main(String[] args) {
    String url = "http://zouchanglin.cn/info/create";
    OkHttpClient okHttpClient = new OkHttpClient();
    Map<String, Object> map = new HashMap<>();
    map.put("name", "Mike");
    map.put("age", "20");
    RequestBody requestBody = RequestBody.create(
        MediaType.parse("application/json; charset=utf-8"),
        JSONObject.toJSONString(map));
    Request request = new Request.Builder().post(requestBody).url(url).build();
    try {
        Response response = okHttpClient.newCall(request).execute();
        System.out.println(response.body().string());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
```

2、表单数据

```java
public static void main(String[] args) {
    String url = "http://zouchanglin.cn/info/create";
    OkHttpClient okHttpClient = new OkHttpClient();
    RequestBody requestBody = new FormBody.Builder()
        .add("name", "Mike")
        .add("age", "20").build();
    Request request = new Request.Builder().post(requestBody).url(url).build();
    try {
        Response response = okHttpClient.newCall(request).execute();
        System.out.println(response.body().string());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
```

# 3、Delete请求示例

```java
public static void main(String[] args) {
    String url = "http://zouchanglin.cn/info/remove";
    OkHttpClient okHttpClient = new OkHttpClient();
    RequestBody requestBody = new FormBody.Builder()
        .add("id", "001002003004").build();
    Request request = new Request.Builder()
        .delete(requestBody).url(url).build();
    try {
        Response response = okHttpClient.newCall(request).execute();
        System.out.println(response.body().string());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
```

# 4、附加请求头示例

```java
public static void main(String[] args) {
    String url = "http://zouchanglin.cn/info/remove";
    OkHttpClient okHttpClient = new OkHttpClient();
    RequestBody requestBody = new FormBody.Builder()
        .add("id", "001002003004").build();
    Request request = new Request.Builder()
        .delete(requestBody)
        .addHeader("Accept", "application/vnd..")
        .url(url).build();
    try {
        Response response = okHttpClient.newCall(request).execute();
        System.out.println(response.body().string());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
```

# 5、请求异步回调示例

```java
public static void main(String[] args) {
    String url = "http://zouchanglin.cn/info/remove";
    OkHttpClient okHttpClient = new OkHttpClient();
    RequestBody requestBody = new FormBody.Builder()
        .add("id", "0010003004").build();
    Request request = new Request.Builder().delete(requestBody).url(url).build();
    Call call = okHttpClient.newCall(request);
    call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            //TODO...
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            //TODO...
        }
    });
}
```

# 6、上传文件加参数示例

```java
@PostMapping("upload")
public String uploadToRemoteHost(String ip, String path, String fileId) {
    String url = String.format("http://%s:8080//api/host/file/create/", ip);
    //找到文件对象
    Optional<ImageFile> bigFileById = fileService.getBigFileById(fileId);
    if(bigFileById.isPresent()){
        ImageFile imageFile = bigFileById.get();
        OkHttpClient okHttpClient = new OkHttpClient();
        MultipartBody.Builder requestBody = new MultipartBody.Builder();
        requestBody.setType(MultipartBody.FORM);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/octet-stream"), 
            imageFile.getContent().getData());
        
        // 参数分别为 请求key 文件名称 RequestBody
        requestBody.addFormDataPart("file", imageFile.getName(), body);
        //要上传的文字参数
        Map<String, String> map = new HashMap<>();
        map.put("name", imageFile.getName());
        map.put("path", path);
        for (String key : map.keySet()) {
            requestBody.addFormDataPart(key, map.get(key));
        }
        MultipartBody build = requestBody.build();
        try {
            Request request = new Request.Builder().post(build).url(url).build();
            Response execute = okHttpClient.newCall(request).execute();
            if(execute.isSuccessful()){
                return execute.body().string();
            }
            return JSONObject.toJSONString(ResultVOUtil.error(1, "网络错误"));
        } catch (IOException e) {
            e.printStackTrace();
            return JSONObject.toJSONString(ResultVOUtil.error(2, "网络错误2"));
        }
    }
    return JSONObject.toJSONString(ResultVOUtil.error(3, "文件不存在"));
}
```

# 7、下载文件示例

```java
public void downloadImg(View view){
    OkHttpClient client = new OkHttpClient();
    final Request request = new Request.Builder().get()
            .url("http://wwwx.yyy/a.png")
            .build();
    Call call = client.newCall(request);
    call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            Log.e("moer", "onFailure: ");;
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            //拿到字节流
            InputStream is = response.body().byteStream();

            int len = 0;
            File file  = new File(Environment.getExternalStorageDirectory(), "n.png");
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buf = new byte[128];

            while ((len = is.read(buf)) != -1){
                fos.write(buf, 0, len);
            }

            fos.flush();
            //关闭流
            fos.close();
            is.close();
        }
    });
}

```



# 8、OkHttp的坑

OkHttp请求回调中response.body().string()只能有效调用一次，调用response.body().string()的时候数据流已经关闭了，再次调用就是提示已经closed，抛出java.lang.IllegalStateException: closed异常，所以这个坑还是有点大，我在debug的时候由于已经监视了一次response.body().string()的返回值，在代码中跑完就是IllegalStateException。 调试代码调试时，表达式的监视有时候会影响代码的运行，比如就像OkHttp这种情况。

OkHttp的使用与跳坑示例

![mark](https://img.zouchanglin.cn///20200321/vL5w2LvCRPhV.png)

上图即使我搭建完毕的效果。对于Docker的环境安装，基础命令之类的内容，通读官网文档内容基本都能顺利掌握。 然而，当笔者尝试着搭建一套基于SSL的Docker Registry（官网推荐的做法）却遇到了不少的麻烦，对于这部分内容，大多数博客文档内容都是直接跳过了SSL的环节，采用了HTTP的访问形式。 然而本文就是记录一下对于搭建HTTPS 访问形式的Docker Registry的过程，读者很容易复现的过程！

我的环境是CentOS7_x64，Docker版本是 Client: Docker Engine - Community 19.03.7、Server: Docker Engine - Community 19.03.7、Nginx源码包的版本是nginx-1.9.9.tar.gz。



# 1、获取HTTPS证书

就以我的域名为例吧，这是我准备的二级域名 docker.zouchanglin.cn：
![mark](https://img.zouchanglin.cn///20200321/lmro1eOePhdb.png)

如何获得这个二级域名的HTTPS的证书呢？进入这个网站可以申请免费的HTTPS证书： **https://freessl.cn/** ，点击创建，于是就会提示安装一个KeyManager的软件，下载之后安装即可，设置密码即可运行。

![mark](https://img.zouchanglin.cn///20200321/qxiFIwjJqIx7.png)

按照提示的需求配置好解析即可，配置完成之后测试一下是否正常解析，网页上有工具的点一下就行

![mark](https://img.zouchanglin.cn///20200321/nR8EYzDj8sXJ.png)

获取成功之后在Key Manager里就会出现秘钥：

![mark](https://img.zouchanglin.cn///20200321/Ol8am03G8QW5.png)

接下来导出一个Nginx用的证书就好了：

![mark](https://img.zouchanglin.cn///20200321/wrEmWxK723tu.png)

# 2、安装并配置Nginx

关于Nginx的安装可以参考我之前的博客[《CentOS7编译安装nginx》](https://zouchanglin.cn/2020/01/29/3245705396.html) 可以一开始就把HTTPS模块包含进去，不然得二次编译，如何配置Nginx呢？

我已经把下载好的证书上传至Linux服务器并解压，解压后得到crt和key两个文件，我把它们放在了/usr/local/certs下面。

还是先给原来的Nginx备份一下，再做修改：

```nginx
user root;

worker_processes  1;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
	
    sendfile        on;
    keepalive_timeout  65;
    gzip  on;


    # HTTPS server
    #
    server {
        listen       443 ssl;
        server_name  localhost;
		client_max_body_size 0;
        ssl_certificate      /usr/local/certs/docker.zouchanglin.cn_chain.crt;
        ssl_certificate_key  /usr/local/certs/docker.zouchanglin.cn_key.key;
        ssl on;
        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;

        ssl_ciphers  HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers  on;
        location ~ {
                proxy_pass_header Server;
                proxy_pass https://registry;
        }
    }
	
    upstream registry {
                server 127.0.0.1:5000;
    }
}
```

client_max_body_size这个配置是为了防止nginx 之 413 Request Entity Too Large（请求实体太大）这个错误，

最后，nginx启动一下！

```bash
nginx
```

# 3、Docker私服运行

直接一条命令就很OK了：

```bash
docker run -d \
  -p 5000:5000 \
  -v /usr/local/registry:/var/lib/registry \
  -v /usr/local/certs:/certs \
  -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/docker.zouchanglin.cn_chain.crt \
  -e REGISTRY_HTTP_TLS_KEY=/certs/docker.zouchanglin.cn_key.key \
  -e REGISTRY_STORAGE_DELETE_ENABLED=true \
  --restart=always \
  --name registry \
  registry:2
```

`-e REGISTRY_STORAGE_DELETE_ENABLED=true` 这条指令主要是打开删除镜像的限制！

# 4、检验是否配置成功

![mark](https://img.zouchanglin.cn///20200321/vL5w2LvCRPhV.png)

Docker私服配置HTTPS

单例模式属于创建型设计模式，一个类在虚拟机中只有一份实例。实现单例模式的核心思想在于构造函数私有化，主要实现方式分为两种：懒汉式和饿汉式。

![mark](https://img.zouchanglin.cn///20200318/uUtN2uPGYzCk.png)



# 饿汉式-线程安全

```java
//饿汉式单例
public class HungryTypeSingleByFinal {
    private static final HungryTypeSingleByFinal hungryTypeSingle = new HungryTypeSingleByFinal();

    public static HungryTypeSingleByFinal getInstance(){
        return hungryTypeSingle;
    }

    private HungryTypeSingleByFinal(){}
}
```

# 饿汉式-线程安全

与上面一样，都是在类加载的时候就完成了初始化

```java
//饿汉式单例
public class HungryTypeSingleByStaticBlock {
    private static HungryTypeSingleByStaticBlock hungryTypeSingleByStaticBlock;
    static {
        hungryTypeSingleByStaticBlock = new HungryTypeSingleByStaticBlock();
    }
    private HungryTypeSingleByStaticBlock(){}

    public static HungryTypeSingleByStaticBlock getInstance(){
        return hungryTypeSingleByStaticBlock;
    }
}
```

# 懒汉式-线程不安全

```java
//懒汉式单例(多线程下不安全)
public class LazyTypeSingleNoSafe {
    private static LazyTypeSingleNoSafe lazyTypeSingleNoSafe;

    public static LazyTypeSingleNoSafe getInstance(){
        if(lazyTypeSingleNoSafe == null){
            lazyTypeSingleNoSafe = new LazyTypeSingleNoSafe();
        }
        return lazyTypeSingleNoSafe;
    }

    private LazyTypeSingleNoSafe(){}
}
```

# 懒汉式-方法加锁-线程安全

```java
//懒汉式单例 + 获取对象加锁
public class LazyTypeSingleSafe {
    private static LazyTypeSingleSafe lazyTypeSingleSafe;

    public static synchronized LazyTypeSingleSafe getInstance(){
        if(lazyTypeSingleSafe == null){
            lazyTypeSingleSafe = new LazyTypeSingleSafe();
        }
        return lazyTypeSingleSafe;
    }

    private LazyTypeSingleSafe(){}
}
```



# 懒汉式-双重检查-线程安全

```java
//懒汉式单例 + 双重锁检查
public class LazyTypeSingleSafeDoubleCheck {
    private static LazyTypeSingleSafeDoubleCheck lazyTypeSingleSafeDoubleCheck;
    public static LazyTypeSingleSafeDoubleCheck getInstance(){
        if(lazyTypeSingleSafeDoubleCheck == null){
            synchronized (LazyTypeSingleSafeDoubleCheck.class){
                if(lazyTypeSingleSafeDoubleCheck == null){
                    lazyTypeSingleSafeDoubleCheck = new LazyTypeSingleSafeDoubleCheck();
                }
            }
        }
        return lazyTypeSingleSafeDoubleCheck;
    }
    private LazyTypeSingleSafeDoubleCheck(){}
}
```

这种做法相对于上面的做法的好处就是，如果已经实例化了则直接返回对象，而不是像上面那样每次都进入同步方法，双重检查只是在对象未初始化的时候加锁，一旦对象已经初始化则后面的线程无需加锁直接获取到了单例对象，无疑减小了开销。

> **表面看起来线程安全，逻辑也没问题，实则有漏洞，后面会讲**

# 懒汉式-静态内部类-线程安全(推荐)

```java
//懒汉式单例 静态内部类实现（推荐）
public class LazyTypeSingleSafeInnerClass {
    private static class LazyTypeSingleSafeInnerClassHolder{
        private static LazyTypeSingleSafeInnerClass singleSafe = new LazyTypeSingleSafeInnerClass();
    }
    public static LazyTypeSingleSafeInnerClass getInstance(){
        return LazyTypeSingleSafeInnerClassHolder.singleSafe;
    }
    private LazyTypeSingleSafeInnerClass(){}
}
```

这种方式是比较推荐的方式，从外部无法访问静态内部类LazyTypeSingleSafeInnerClassHolder，只有当调用LazyTypeSingleSafeInnerClass.getInstance方法的时候，才能得到单例对象singleSafe。 这里要注意的是singleSafe对象初始化的时机并不是在单例类LazyTypeSingleSafeInnerClass被加载的时候，而是在调用getInstance方法，使得静态内部类LazyTypeSingleSafeInnerClassHolder被加载的时候。因此这种实现方式是利用classloader的加载机制来实现懒加载，并保证构建单例的线程安全。 

# 无法破解的单例模式

上述单例模式都可以通过反射的方式构造出新的对象，毕竟反射大法香呀：

```java
public static void testLazyTypeSingleSafeInnerClass() throws Exception {
    System.out.println(LazyTypeSingleSafeInnerClass.getInstance() == LazyTypeSingleSafeInnerClass.getInstance());
    //true
    Class<LazyTypeSingleSafeInnerClass> innerClassClass = LazyTypeSingleSafeInnerClass.class;
    Constructor<LazyTypeSingleSafeInnerClass> constructor = innerClassClass.getDeclaredConstructor(null);
    constructor.setAccessible(true);

    System.out.println(constructor.newInstance(null) == constructor.newInstance(null));
    //false
}

public static void threadEnvTest() throws InterruptedException {
    Set<LazyTypeSingleNoSafe> typeSingleNoSafeList = new HashSet<>();

    AtomicInteger atomicInteger = new AtomicInteger(0);

    while(atomicInteger.getAndSet(atomicInteger.intValue() + 1) < 50){
        new Thread(()->{
            LazyTypeSingleNoSafe instance = LazyTypeSingleNoSafe.getInstance();
            typeSingleNoSafeList.add(instance);
        }).start();
    }

    for(LazyTypeSingleNoSafe lazyTypeSingleNoSafe: typeSingleNoSafeList){
        System.out.println(lazyTypeSingleNoSafe);
    }
    //single.LazyTypeSingleNoSafe@6e5802d8
    //single.LazyTypeSingleNoSafe@6706a70b
    //single.LazyTypeSingleNoSafe@51a22f1d
}
```

通过上述例子我们也看到了，在反射眼里，一切都是弟弟，所以我们根本不可能造出真正的单例，但是我们却可以通过枚举这个特性来实现绝对的单例模式和多例模式！

```java
//绝对的单例模式（之前的通过反射都可以破解）
public enum AbsoluteSingleSafe {
    ONLY_ONE_SINGLE
}
```

我们破解一下枚举试试：

```java
public static void testAbsoluteSingleSafe() throws Exception {
    System.out.println(AbsoluteSingleSafe.ONLY_ONE_SINGLE == AbsoluteSingleSafe.ONLY_ONE_SINGLE);
    //true

    Class<AbsoluteSingleSafe> absoluteSingleSafeClass = AbsoluteSingleSafe.class;
    Constructor<AbsoluteSingleSafe> constructor = absoluteSingleSafeClass.getDeclaredConstructor(null);
    constructor.setAccessible(true);
    System.out.println(constructor.newInstance(null) == constructor.newInstance(null));
    //Exception in thread "main" java.lang.NoSuchMethodException: single.AbsoluteSingleSafe.<init>()
}
```

# DoubleCheck的隐患

我们回顾一下DoubleCheck的代码：

```java
public class LazyTypeSingleSafeDoubleCheck {
    private static LazyTypeSingleSafeDoubleCheck lazyTypeSingleSafeDoubleCheck;
    public static LazyTypeSingleSafeDoubleCheck getInstance(){
        if(lazyTypeSingleSafeDoubleCheck == null){
            synchronized (LazyTypeSingleSafeDoubleCheck.class){
                if(lazyTypeSingleSafeDoubleCheck == null){
                    lazyTypeSingleSafeDoubleCheck = new LazyTypeSingleSafeDoubleCheck();
                }
            }
        }
        return lazyTypeSingleSafeDoubleCheck;
    }
    private LazyTypeSingleSafeDoubleCheck(){}
}
```

问题出在哪里呢？

我们可以假设这样的情况，当两个线程一先一后访问getInstance方法的时候，当A线程正在构建对象，B线程刚刚进入方法： 

![mark](https://img.zouchanglin.cn///20200318/Pum42vPeK7DV.png)

这种情况表面看似没什么问题，要么Instance还没被线程A构建，线程B执行if(lazyTypeSingleSafeDoubleCheck== null)的时候得到true；要么Instance已经被线程A构建完成，线程B执行 if(lazyTypeSingleSafeDoubleCheck== null)的时候得到false。真是如此吗？答案是否定的。这里涉及到了JVM编译器的指令重排。 

一句简单的`lazyTypeSingleSafeDoubleCheck = new LazyTypeSingleSafeDoubleCheck();`  会被编译器编译成如下JVM指令 :

memory = allocate(); //1：分配对象的内存空间

ctorInstance(memory); //2：初始化对象

instance =memory; //3：设置instance指向刚分配的内存地址

但是这些指令顺序并非一成不变，有可能会经过JVM和CPU的优化，指令重排成下面的顺序：

memory =allocate(); //1：分配对象的内存空间

instance =memory; //3：设置instance指向刚分配的内存地址

ctorInstance(memory); //2：初始化对象

当线程A执行完1和3时，instance对象还未完成初始化，但已经不再指向null。此时如果线程B抢占到CPU资源，执行 if(instance == null)的结果会是false，从而返回一个没有初始化完成的instance对象。如下图所示： 

![mark](https://img.zouchanglin.cn///20200318/2KqgLMzpzw10.png)

由于线程A还未完成初始化工作，但是线程B检测到对象已经不为空，于是最终返回的是空对象！！那么应该如何避免呢？其实只需要在instance对象前面增加一个修饰符volatile就好了，关于可以看[《重新认识volatile》](https://zouchanglin.cn/2019/12/11/3728000607.html) 这篇文章，里面讲述的比较详细，在此不再赘述。所以完整的双重检查的代码是：

```java
//懒汉式单例 + 双重锁检查
public class LazyTypeSingleSafeDoubleCheck {
    private volatile static LazyTypeSingleSafeDoubleCheck lazyTypeSingleSafeDoubleCheck;
    public static LazyTypeSingleSafeDoubleCheck getInstance(){
        if(lazyTypeSingleSafeDoubleCheck == null){
            synchronized (LazyTypeSingleSafeDoubleCheck.class){
                if(lazyTypeSingleSafeDoubleCheck == null){
                    lazyTypeSingleSafeDoubleCheck = new LazyTypeSingleSafeDoubleCheck();
                }
            }
        }
        return lazyTypeSingleSafeDoubleCheck;
    }
    private LazyTypeSingleSafeDoubleCheck(){}
}
```

# 单例模式的总结

所以如果想要实现线程安全的单例模式，可以使用饿汉式、DoubleCheck（加volatile的版本），静态内部类，枚举等方式；想要使用懒加载策略就不能使用枚举了，只能DoubleCheck（加volatile的版本），静态内部类；如果想实现反射也无法破解的单例那么只能用枚举了，但是一般情况下不会去刻意排斥反射。所以比较推荐的方案还是静态内部类，简单实用而且线程安全。