synchronized使用和原理全解

左手的ㄟ右手 2023-06-13 04:42 38阅读 0赞

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

**修饰一个方法**

**被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；**

**修饰一个静态的方法**

**其作用的范围是整个静态方法，作用的对象是这个类的所有对象；**

**修饰一个代码块**

**被修饰的代码块称为同步语句块，其作用的范围是大括号\{\}括起来的代码，作用的对象是调用这个代码块的对象；**

**修饰一个类**

**其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。**

# 修饰一个方法 #

**被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；**

如果多个线程访问同一个对象的实例变量，可能出现非线程安全问题。

![20191113213256883.png][]

例子：**a线程set后sleep2000ms，看b线程是否可以趁机set，造成非线程安全**

HasSelfPrivateNum.java:

package service;
    
    public class HasSelfPrivateNum {
    
    	private int num = 0;
    
    	public void addI(String username) {
    		try {
    			if (username.equals("a")) {
    				num = 100;
    				System.out.println("a set over!");
    				Thread.sleep(2000);
    			} else {
    				num = 200;
    				System.out.println("b set over!");
    			}
    			System.out.println(username + " num=" + num);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

package extthread;
    
    import service.HasSelfPrivateNum;
    
    public class ThreadA extends Thread {
    
    	private HasSelfPrivateNum numRef;
    
    	public ThreadA(HasSelfPrivateNum numRef) {
    		super();
    		this.numRef = numRef;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		numRef.addI("a");
    	}
    
    }

package extthread;
    
    import service.HasSelfPrivateNum;
    
    public class ThreadB extends Thread {
    
    	private HasSelfPrivateNum numRef;
    
    	public ThreadB(HasSelfPrivateNum numRef) {
    		super();
    		this.numRef = numRef;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		numRef.addI("b");
    	}
    
    }

run：

package test;
    
    import service.HasSelfPrivateNum;
    import extthread.ThreadA;
    import extthread.ThreadB;
    
    public class Run {
    	public static void main(String[] args) {
    
    		HasSelfPrivateNum numRef = new HasSelfPrivateNum();
    
    		ThreadA athread = new ThreadA(numRef);
    		athread.start();
    
    		ThreadB bthread = new ThreadB(numRef);
    		bthread.start();
    
    	}
    }

结果：**a线程set后sleep2000ms，b线程可以趁机set，造成非线程安全**

![20191113213605147.png][]

**这时我们使用**synchronized修饰addI方法：

package service;
    
    public class HasSelfPrivateNum {
    
    	private int num = 0;
    
    	synchronized public void addI(String username) {
    		try {
    			if (username.equals("a")) {
    				num = 100;
    				System.out.println("a set over!");
    				Thread.sleep(2000);
    			} else {
    				num = 200;
    				System.out.println("b set over!");
    			}
    			System.out.println(username + " num=" + num);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

结果：B不能set了，说明线程安全。

![20191113213815911.png][]

注意：我们取得的是对象锁，也就是说，一个对象一个锁，而不是锁住整个类或者代码或者方法。

例子：**两个对象两个锁**

myobject.java

打印名字后sleep，最后打印end

package extobject;
    
    public class MyObject {
    
    	synchronized public void methodA() {
    		try {
    			System.out.println("begin methodA threadName="
    					+ Thread.currentThread().getName());
    			Thread.sleep(5000);
    			System.out.println("end");
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

package extthread;
    
    import extobject.MyObject;
    
    public class ThreadA extends Thread {
    
    	private MyObject object;
    
    	public ThreadA(MyObject object) {
    		super();
    		this.object = object;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		object.methodA();
    	}
    
    }

package extthread;
    
    import extobject.MyObject;
    
    public class ThreadB extends Thread {
    
    	private MyObject object;
    
    	public ThreadB(MyObject object) {
    		super();
    		this.object = object;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		object.methodA();
    	}
    }

RUN:

package test.run;
    
    import extobject.MyObject;
    import extthread.ThreadA;
    import extthread.ThreadB;
    
    public class Run {
    
    	public static void main(String[] args) {
    		MyObject object = new MyObject();
    		ThreadA a = new ThreadA(object);
    		a.setName("A");
    		ThreadB b = new ThreadB(object);
    		b.setName("B");
    
    		a.start();
    		b.start();
    	}
    
    }

结果：两个对象互不影响，各自运行各自上锁

![20191113214420342.png][]

**其它方法被调用是什么效果呢？**

之前做实验是因为怕大家不理解知识，现在大家已经有了一定的基础，这个结论不再做实验。

**结论：**

**如果A线程持有x对象的锁，B线程不可调用synchronized修饰的方法，但是可以异步调用没有被synchronized修饰的方法**

**synchronized具有锁重入功能，也就是说一个线程获得锁，再次请求是可以再次得到对象的锁的**

下面做实验验证这个结论：

service.java

package myservice;
    
    public class Service {
    
    	synchronized public void service1() {
    		System.out.println("service1");
    		service2();
    	}
    
    	synchronized public void service2() {
    		System.out.println("service2");
    		service3();
    	}
    
    	synchronized public void service3() {
    		System.out.println("service3");
    	}
    
    }

thread:

package extthread;
    
    import myservice.Service;
    
    public class MyThread extends Thread {
    	@Override
    	public void run() {
    		Service service = new Service();
    		service.service1();
    	}
    
    }

run:

package test;
    
    import extthread.MyThread;
    
    public class Run {
    	public static void main(String[] args) {
    		MyThread t = new MyThread();
    		t.start();
    	}
    }

结果验证了上面的结论：  
![20191113215425566.png][]

注：**在父子类之间同样适用**，不再做实验

但是如果一个线程出现了异常，难道就永远锁住了资源吗？其实不是的，**出现异常自动释放锁**。

实验：让a锁住对象后出现异常，看b是否可以拿到锁，代码不再展示。

![20191113215908139.png][]

结果：b可以正常执行。

# **修饰一个静态的方法** #

**其作用的范围是整个静态方法，作用的对象是这个类的所有对象；**

**也就是说整个类就一个锁，这也和静态的概念相符（静态方法和属性是属于类的而不是具体一个对象的）**

**让我们来验证这个结论：**

service：

package service;
    
    public class Service {
    
    	synchronized public static void printA() {
    		try {
    			System.out.println("线程名称为：" + Thread.currentThread().getName()
    					+ "在" + System.currentTimeMillis() + "进入printA");
    			Thread.sleep(3000);
    			System.out.println("线程名称为：" + Thread.currentThread().getName()
    					+ "在" + System.currentTimeMillis() + "离开printA");
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    	synchronized public static void printB() {
    		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
    				+ System.currentTimeMillis() + "进入printB");
    		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
    				+ System.currentTimeMillis() + "离开printB");
    	}
    
    }

a：

package extthread;
    
    import service.Service;
    
    public class ThreadA extends Thread {
    	private Service service;
    
    	public ThreadA(Service service) {
    		super();
    		this.service = service;
    	}
    
    	@Override
    	public void run() {
    		service.printA();
    	}
    }

b：

package extthread;
    
    import service.Service;
    
    public class ThreadB extends Thread {
    	private Service service;
    
    	public ThreadB(Service service) {
    		super();
    		this.service = service;
    	}
    
    	@Override
    	public void run() {
    		service.printB();
    	}
    }

run：

package test;
    
    import service.Service;
    import extthread.ThreadA;
    import extthread.ThreadB;
    
    public class Run {
    
    	public static void main(String[] args) {
    
    		Service service1 = new Service();
    		Service service2 = new Service();
    
    		ThreadA a = new ThreadA(service1);
    		a.setName("A");
    		a.start();
    
    		ThreadB b = new ThreadB(service2);
    		b.setName("B");
    		b.start();
    
    	}
    
    }

结果：

![20191113221145454.png][]

但是，请注意一个显而易见的结论：**a线程访问synchronized修饰的静态方法时，b线程可以访问synchronized修饰的非静态方法，原因也很容易想到：静态方法是属于类的，普通方法是属于对象本身的，所以一个是对象锁，一个是class锁，不会影响。**

**为了验证这个结论，我们做实验看看结果。**

service：

AB为静态的，C普通的。

a：

b：

c：

package extthread;
    
    import service.Service;
    
    public class ThreadC extends Thread {
    
    	private Service service;
    
    	public ThreadC(Service service) {
    		super();
    		this.service = service;
    	}
    
    	@Override
    	public void run() {
    		service.printC();
    	}
    }

run：

package test;
    
    import service.Service;
    import extthread.ThreadA;
    import extthread.ThreadB;
    import extthread.ThreadC;
    
    public class Run {
    
    	public static void main(String[] args) {
    
    		Service service = new Service();
    
    		ThreadA a = new ThreadA(service);
    		a.setName("A");
    		a.start();
    
    		ThreadB b = new ThreadB(service);
    		b.setName("B");
    		b.start();
    
    		ThreadC c = new ThreadC(service);
    		c.setName("C");
    		c.start();
    
    	}
    
    }

结果：

![20191114082402174.png][]

说明：验证了结论，因为AB同步执行，C异步执行。

# **修饰一个代码块** #

**被修饰的代码块称为同步语句块，其作用的范围是大括号\{\}括起来的代码，作用的对象是调用这个代码块的对象；（而不一定是本对象了）**

（**synchronized方法是对当前对象加锁，synchronized代码块是对某个对象加锁**）

用synchronized声明方法是有弊端的，比如A调用同步方法执行一个很长时间的任务，这时B就必须等待，有时候这种长时间等待是低效率且没有必要的，这时我们就要认识一下synchronized同步代码块了。

格式是这样的：synchronized(类名)\{......\}

我们先来认识第一种用法来体会修饰代码块的好处：

**synchronized(this)同步代码块：**a调用相关代码后，b对其它synchronized方法和synchronized(this)同步代码块调用会阻塞。但是没有被synchronized修饰的代码就得以执行，不像之前修饰方法那么死板了。

我们来看一个例子：

第一个循环异步，第二个循环同步：

package mytask;
    
    public class Task {
    
    	public void doLongTimeTask() {
    		for (int i = 0; i < 100; i++) {
    			System.out.println("nosynchronized threadName="
    					+ Thread.currentThread().getName() + " i=" + (i + 1));
    		}
    		System.out.println("");
    		synchronized (this) {
    			for (int i = 0; i < 100; i++) {
    				System.out.println("synchronized threadName="
    						+ Thread.currentThread().getName() + " i=" + (i + 1));
    			}
    		}
    
    	}
    }

thread1：

package mythread;
    
    import mytask.Task;
    
    public class MyThread1 extends Thread {
    
    	private Task task;
    
    	public MyThread1(Task task) {
    		super();
    		this.task = task;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		task.doLongTimeTask();
    	}
    
    }

thread2：

package mythread;
    
    import mytask.Task;
    
    public class MyThread2 extends Thread {
    
    	private Task task;
    
    	public MyThread2(Task task) {
    		super();
    		this.task = task;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		task.doLongTimeTask();
    	}
    
    }

run：

package test;
    
    import mytask.Task;
    import mythread.MyThread1;
    import mythread.MyThread2;
    
    public class Run {
    
    	public static void main(String[] args) {
    		Task task = new Task();
    
    		MyThread1 thread1 = new MyThread1(task);
    		thread1.start();
    
    		MyThread2 thread2 = new MyThread2(task);
    		thread2.start();
    	}
    }

结果：

在非同步代码块时，是交叉打印的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70][]

同步代码块时排队执行：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1][]

另一个用法：

**synchronized(非this)同步代码块（也就是说将任意对象作为对象监视器）：**

格式：**synchronized(非this对象x)\{......\}**

**1、当多个线程持有的对象监听器为同一个对象时，依旧是同步的，同一时间只有一个可以访问，**

**2、但是对象不同，执行就是异步的。**

这样有什么好处呢？

（因为如果一个类有很多synchronized方法或synchronized（this）代码块，还是会影响效率，这时用**synchronized(非this)同步代码块就不会和其它锁this同步方法争抢this锁）**

实验

第一点我们就不验证了，因为体现不出它的好处，我们验证第二点：

service：

一个同步非this代码块，一个同步方法：

package service;
    
    public class Service {
    
    	private String anyString = new String();
    
    	public void a() {
    		try {
    			synchronized (anyString) {
    				System.out.println("a begin");
    				Thread.sleep(3000);
    				System.out.println("a   end");
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    	synchronized public void b() {
    		System.out.println("b begin");
    		System.out.println("b   end");
    	}
    
    }

a：

b：

package extthread;
    
    import service.Service;
    
    public class ThreadB extends Thread {
    
    	private Service service;
    
    	public ThreadB(Service service) {
    		super();
    		this.service = service;
    	}
    
    	@Override
    	public void run() {
    		service.b();
    
    	}
    
    }

run：

package test;
    
    import service.Service;
    import extthread.ThreadA;
    import extthread.ThreadB;
    
    public class Run {
    
    	public static void main(String[] args) {
    		Service service = new Service();
    
    		ThreadA a = new ThreadA(service);
    		a.setName("A");
    		a.start();
    
    		ThreadB b = new ThreadB(service);
    		b.setName("B");
    		b.start();
    
    	}
    
    }

结果：

![20191114094921199.png][]

确实是异步的。

最后一个要注意的点：我们知道**synchronized(非this对象x)\{......\}是将对象x监视，这也就意味着当线程a调用这段代码时，线程b调用类x中的同步方法和代码块也会是同步的效果（阻塞）。**

**为了让大家更明白，做最后一个例子：**

首先创建一个有静态方法的类：

package test2.extobject;
    
    public class MyObject {
    	synchronized public void speedPrintString() {
    		System.out.println("speedPrintString ____getLock time="
    				+ System.currentTimeMillis() + " run ThreadName="
    				+ Thread.currentThread().getName());
    		System.out.println("-----------------");
    		System.out.println("speedPrintString releaseLock time="
    				+ System.currentTimeMillis() + " run ThreadName="
    				+ Thread.currentThread().getName());
    	}
    }

然后用 **synchronized(非this对象x)\{......\}**的形式引用它，并进入这个代码块，然后看看这时这个静态方法是否可以被调用。

service：作用是**synchronized(object)**

package test2.service;
    
    import test2.extobject.MyObject;
    
    public class Service {
    
    	public void testMethod1(MyObject object) {
    		synchronized (object) {
    			try {
    				System.out.println("testMethod1 ____getLock time="
    						+ System.currentTimeMillis() + " run ThreadName="
    						+ Thread.currentThread().getName());
    				Thread.sleep(5000);
    				System.out.println("testMethod1 releaseLock time="
    						+ System.currentTimeMillis() + " run ThreadName="
    						+ Thread.currentThread().getName());
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    }

threadA：

package test2.extthread;
    
    import test2.extobject.MyObject;
    import test2.service.Service;
    
    public class ThreadA extends Thread {
    
    	private Service service;
    	private MyObject object;
    
    	public ThreadA(Service service, MyObject object) {
    		super();
    		this.service = service;
    		this.object = object;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		service.testMethod1(object);
    	}
    
    }

threadB：

package test2.extthread;
    
    import test2.extobject.MyObject;
    
    public class ThreadB extends Thread {
    	private MyObject object;
    
    	public ThreadB(MyObject object) {
    		super();
    		this.object = object;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		object.speedPrintString();
    	}
    }

run：

package test2.run;
    
    import test2.extobject.MyObject;
    import test2.extthread.ThreadA;
    import test2.extthread.ThreadB;
    import test2.service.Service;
    
    public class Run {
    
    	public static void main(String[] args) throws InterruptedException {
    		Service service = new Service();
    		MyObject object = new MyObject();
    
    		ThreadA a = new ThreadA(service, object);
    		a.setName("a");
    		a.start();
    
    		Thread.sleep(100);
    
    		ThreadB b = new ThreadB(object);
    		b.setName("b");
    		b.start();
    	}
    
    }

结果：

![20191114101400804.png][]

是同步的。

当然，把修饰方法改为修饰代码块也是一样不能被执行的。

Synchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。

# **synchronized底层原理** #

在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统来实现，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高。

**在 Java 6 之后从 JVM 层面对synchronized 较大优化，锁的实现引入了如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。**

synchronized **同步语句块**的实现使用的是 monitorenter 和 monitorexit 指令。

其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。

当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

synchronized **修饰的方法**并没有 monitorenter 指令和 monitorexit 指令，取得代之的是ACC\_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC\_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。但是原理其实都是类似的。**具体的实现是操作系统的知识可以去翻我操作系统的文章。**

# 锁详解 #

锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

**自旋**：当有个线程A去请求某个锁的时候，这个锁正在被其它线程占用，但是线程A并不会马上进入阻塞状态，而是循环请求锁(自旋)。这样做的目的是因为很多时候持有锁的线程会很快释放锁的，线程A可以尝试一直请求锁，没必要被挂起放弃CPU时间片，因为线程被挂起然后到唤醒这个过程开销很大,当然如果线程A自旋指定的时间还没有获得锁，仍然会被挂起。

**自适应性自旋**：自适应性自旋是自旋的升级、优化，自旋的时间不再固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态决定。例如线程如果自旋成功了，那么下次自旋的次数会增多，因为JVM认为既然上次成功了，那么这次自旋也很有可能成功，那么它会允许自旋的次数更多。

**锁消除**是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。

**偏向锁**的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那么偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不用做了。偏向锁默认是开启的，也可以关闭。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 3][]

[20191113213256883.png]: https://img-blog.csdnimg.cn/20191113213256883.png
[20191113213605147.png]: https://img-blog.csdnimg.cn/20191113213605147.png
[20191113213815911.png]: https://img-blog.csdnimg.cn/20191113213815911.png
[20191113214420342.png]: https://img-blog.csdnimg.cn/20191113214420342.png
[20191113215425566.png]: https://img-blog.csdnimg.cn/20191113215425566.png
[20191113215908139.png]: https://img-blog.csdnimg.cn/20191113215908139.png
[20191113221145454.png]: https://img-blog.csdnimg.cn/20191113221145454.png
[20191114082402174.png]: https://img-blog.csdnimg.cn/20191114082402174.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191114084853714.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191114085001517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[20191114094921199.png]: https://img-blog.csdnimg.cn/20191114094921199.png
[20191114101400804.png]: https://img-blog.csdnimg.cn/20191114101400804.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191114103007936.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191114103009988.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70