27_多线程_第27天（线程安全、线程同步、等待唤醒机制、单例设计模式）_讲义

灰太狼 2022-04-04 07:41 83阅读 0赞

# 今日内容介绍 #

# 1、多线程安全问题 #

# 2、等待唤醒机制 #

## 01线程操作共享数据的安全问题 ##

### A:线程操作共享数据的安全问题 ###

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。
    程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

## 02售票的案例 ##

A:售票的案例

package cn.itcast.demo;
    
    public class Tickets implements Runnable{
    	//定义票的票源
    	private int ticket = 100;
    	private Object obj = new Object();
    	
    	public void run(){
    		while(true){
    			if(ticket > 0){
    				//ticket-- 先打印ticket,在对变量ticket减减
    				System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    			}
    		}
    	}
    }

package cn.itcast.demo;
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//创建Runnable接口实现类对象
    		Tickets t = new Tickets();
    		//创建3个Thread类对象,传递Runnable接口实现类
    		Thread t0 = new Thread(t);
    		Thread t1 = new Thread(t);
    		Thread t2 = new Thread(t);
    		
    		t0.start();
    		t1.start();
    		t2.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]

## 03线程安全问题引发 ##

### A:线程安全问题引发 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]  
模拟线程安全问题爆发，需要做一个宕机，让程序执行到中途，休眠十毫秒，这个时候就会出现cpu空闲，其他线程很可能会抢夺cpu资源，发生线程安全问题

package cn.itcast.demo1;
    /*
     * 通过线程休眠,出现安全问题
     */
    public class Tickets implements Runnable{
    	//定义票的票源
    	private int ticket = 1;
    	private Object obj = new Object();
    	
    	public void run(){
    		while(true){
    			//对票数判断,大于0,可以出售,变量--操作
    			if(ticket > 0){
    				try {
    					Thread.sleep(10);//加了休眠让其他线程执行机会
    				} catch (InterruptedException e) {				
    					e.printStackTrace();
    				}
    				//ticket-- 先打印ticket,在对变量ticket减减
    				System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    			}
    		}
    	}
    }

package cn.itcast.demo1;
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//创建Runnable接口实现类对象
    		Tickets t = new Tickets();
    		//创建3个Thread类对象,传递Runnable接口实现类
    		Thread t0 = new Thread(t);
    		Thread t1 = new Thread(t);
    		Thread t2 = new Thread(t);
    		
    		t0.start();
    		t1.start();
    		t2.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]

## 04同步代码块解决线程安全问题 ##

### A:同步代码块解决线程安全问题 ###

当安全后，你会发现运行速度慢  
未加同步代码块：

package cn.itcast.demo2;
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     */
    public class Tickets implements Runnable{
    	//定义票的票源
    	private int ticket = 3;
    	//造一个对象,不需要向外面提供,直接私有
    	private Object obj = new Object();
    	//线程操作的共享数据在run方法内
    	public void run(){
    		while(true){
    			//线程共享数据,保证安全,加入同步代码块
    			//synchronized (new Object()) -不能是匿名对象，否则每次同步代码块都要更新对象
    			//而实际需要针对同一个对象
    			//synchronized (obj) {
    				//对票数判断,大于0,可以出售,变量--操作
    				if(ticket > 0){
    					try {
    						Thread.sleep(10);//加了休眠让其他线程执行机会
    					} catch (InterruptedException e) {				
    						e.printStackTrace();
    					}
    					//ticket-- 先打印ticket,在对变量ticket减减
    					System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    				}			
    			//}
    		}
    	}
    }

package cn.itcast.demo2;
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		long startTime = System.nanoTime();   //获取开始时间  
    		//创建Runnable接口实现类对象
    		Tickets t = new Tickets();
    		//创建3个Thread类对象,传递Runnable接口实现类
    		Thread t0 = new Thread(t);
    		Thread t1 = new Thread(t);
    		Thread t2 = new Thread(t);
    		
    		t0.start();
    		t1.start();
    		t2.start();
    		long endTime = System.nanoTime(); //获取结束时间  
    
    		System.out.println("程序运行时间： "+(endTime-startTime)+"ns"); 
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
加入同步代码块：

package cn.itcast.demo2;
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     */
    public class Tickets implements Runnable{
    	//定义票的票源
    	private int ticket = 3;
    	//造一个对象,不需要向外面提供,直接私有
    	private Object obj = new Object();
    	//线程操作的共享数据在run方法内
    	public void run(){
    		while(true){
    			//线程共享数据,保证安全,加入同步代码块
    			//synchronized (new Object()) -不能是匿名对象，否则每次同步代码块都要更新对象
    			//而实际需要针对同一个对象
    			synchronized (obj) {
    				//对票数判断,大于0,可以出售,变量--操作
    				if(ticket > 0){
    					try {
    						Thread.sleep(10);//加了休眠让其他线程执行机会
    					} catch (InterruptedException e) {				
    						e.printStackTrace();
    					}
    					//ticket-- 先打印ticket,在对变量ticket减减
    					System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    				}			
    			}
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]

## 05同步代码块的执行原理 ##

### A:同步代码块的执行原理 ###

同步代码块: 在代码块声明上 加上synchronized
     synchronized (锁对象) {
       可能会产生线程安全问题的代码
     }
     同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

![同步代码块原理图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]

## 06同步的上厕所原理 ##

### A:同步的上厕所原理 ###

a:不使用同步:线程在执行的过程中会被打扰
       线程比喻成人
       线程执行代码就是上一个厕所
      第一个人正在上厕所,上到一半,被另外一个人拉出来
    b:使用同步:
       线程比喻成人
       线程执行代码就是上一个厕所
       锁比喻成厕所门
      第一个人上厕所,会锁门
      第二个人上厕所,看到门锁上了,等待第一个人上完再去上厕所

单线程不会有安全问题，安全问题出现在多个线程抢夺执行一个共享数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]

## 07同步方法 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]

#### 同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this ####

package cn.itcast.demo3;
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     * 
     * A 同步方法
     * 采用同步方法形式,解决线程的安全问题
     * 好处：代码简洁
     * 将线程共享数据,和同步,抽取到一个方法中
     * 在方法的声明上,加入同步关键字
     * 
     * 问题：
     * 	  同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
     *   如果方法是静态呢,同步有锁,绝对不是this
     *   锁是本类自己.class属性
     *   静态方法,同步锁,是本类类名.class属性
     */
    public class Tickets implements Runnable{
    	//StringBuffer
    	//StringBuilder
    	//定义票的票源
    	private int ticket = 3;
    	//连对象都不需要使用了
    	//private Object obj = new Object();
    	
    	public void run(){
    		while(true){
    			payTicket();
    			//线程共享数据,保证安全,加入同步代码块
    //			synchronized (obj) {
    				//对票数判断,大于0,可以出售,变量--操作
    //				if(ticket > 0){
    //					try {
    //						Thread.sleep(10);//加了休眠让其他线程执行机会
    //					} catch (InterruptedException e) {				
    //						e.printStackTrace();
    //					}
    					//ticket-- 先打印ticket,在对变量ticket减减
    //					System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    //				}			
    //			}
    		}
    	}
    	//同步方法
    //	public synchronized void payTicket(){
    //		//对票数判断,大于0,可以出售,变量--操作
    //		if(ticket > 0){
    //			try {
    //				Thread.sleep(10);//加了休眠让其他线程执行机会
    //			} catch (InterruptedException e) {				
    //				e.printStackTrace();
    //			}
    //			//ticket-- 先打印ticket,在对变量ticket减减
    //			System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    //		}			
    //	}
    	//同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
    	public void payTicket(){
    		//线程共享数据,保证安全,加入同步代码块
    		//synchronized (this)  this=>t
    		synchronized (this) {
    			//对票数判断,大于0,可以出售,变量--操作
    			if(ticket > 0){
    				try {
    					Thread.sleep(10);//加了休眠让其他线程执行机会
    				} catch (InterruptedException e) {				
    					e.printStackTrace();
    				}
    				//ticket-- 先打印ticket,在对变量ticket减减
    				System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    			}			
    		}		
    	}
    }

package cn.itcast.demo3;
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//创建Runnable接口实现类对象
    		Tickets t = new Tickets();
    		//创建3个Thread类对象,传递Runnable接口实现类
    		Thread t0 = new Thread(t);
    		Thread t1 = new Thread(t);
    		Thread t2 = new Thread(t);
    		
    		t0.start();
    		t1.start();
    		t2.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]

#### A 同步方法 ####

*  采用同步方法形式,解决线程的安全问题
 *  好处：代码简洁
 *  将线程共享数据,和同步,抽取到一个方法中
 *  在方法的声明上,加入同步关键字

package cn.itcast.demo3;
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     * 
     * A 同步方法
     * 采用同步方法形式,解决线程的安全问题
     * 好处：代码简洁
     * 将线程共享数据,和同步,抽取到一个方法中
     * 在方法的声明上,加入同步关键字
     * 
     * 问题：
     * 	  同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
     *   如果方法是静态呢,同步有锁,绝对不是this
     *   锁是本类自己.class属性
     *   静态方法,同步锁,是本类类名.class属性
     */
    public class Tickets implements Runnable{
    	//StringBuffer
    	//StringBuilder
    	//定义票的票源
    	private int ticket = 3;
    	//连对象都不需要使用了
    	//private Object obj = new Object();
    	
    	public void run(){
    		while(true){
    			payTicket();
    		}
    	}
    	//同步方法
    	public synchronized void payTicket(){
    		//对票数判断,大于0,可以出售,变量--操作
    		if(ticket > 0){
    			try {
    				Thread.sleep(10);//加了休眠让其他线程执行机会
    			} catch (InterruptedException e) {				
    				e.printStackTrace();
    			}
    			//ticket-- 先打印ticket,在对变量ticket减减
    			System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    		}			
    	}
    	//同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
    //	public void payTicket(){
    //		//线程共享数据,保证安全,加入同步代码块
    //		//synchronized (this)  this=>t
    //		synchronized (this) {
    //			//对票数判断,大于0,可以出售,变量--操作
    //			if(ticket > 0){
    //				try {
    //					Thread.sleep(10);//加了休眠让其他线程执行机会
    //				} catch (InterruptedException e) {				
    //					e.printStackTrace();
    //				}
    //				//ticket-- 先打印ticket,在对变量ticket减减
    //				System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    //			}			
    //		}		
    //	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]

#### 如果方法是静态呢,同步有锁,绝对不是this ####

package cn.itcast.demo33;
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     * 
     * A 同步方法
     * 采用同步方法形式,解决线程的安全问题
     * 好处：代码简洁
     * 将线程共享数据,和同步,抽取到一个方法中
     * 在方法的声明上,加入同步关键字
     * 
     * 问题：
     * 	  同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
     *   如果方法是静态呢,同步有锁,绝对不是this
     *   锁是本类自己.class属性
     *   静态方法,同步锁,是本类类名.class属性
     */
    public class Tickets implements Runnable{
    	//StringBuffer
    	//StringBuilder
    	//定义票的票源
    	private static int ticket = 3;
    	//连对象都不需要使用了
    	//private Object obj = new Object();
    	
    	public void run(){
    		while(true){
    			payTicket();
    		}
    	}
    	//同步方法
    	//如果方法是静态呢,同步有锁,绝对不是this
    //	public static synchronized void payTicket(){
    //		//对票数判断,大于0,可以出售,变量--操作
    //		if(ticket > 0){
    //			try {
    //				Thread.sleep(10);//加了休眠让其他线程执行机会
    //			} catch (InterruptedException e) {				
    //				e.printStackTrace();
    //			}
    //			//ticket-- 先打印ticket,在对变量ticket减减
    //			System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    //		}			
    //	}
    	
    	//静态方法,同步锁,是本类类名.class属性
    	public static void payTicket(){
    		//线程共享数据,保证安全,加入同步代码块
    		//synchronized (this)  this=>t
    		//synchronized (Tickets.class) ==>  锁是本类自己.class属性 与后面类的加载、反射有关
    		synchronized (Tickets.class) {
    			//对票数判断,大于0,可以出售,变量--操作
    			if(ticket > 0){
    				try {
    					Thread.sleep(10);//加了休眠让其他线程执行机会
    				} catch (InterruptedException e) {				
    					e.printStackTrace();
    				}
    				//ticket-- 先打印ticket,在对变量ticket减减
    				System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    			}			
    		}		
    	}
    }

package cn.itcast.demo33;
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//创建Runnable接口实现类对象
    		Tickets t = new Tickets();
    		//创建3个Thread类对象,传递Runnable接口实现类
    		Thread t0 = new Thread(t);
    		Thread t1 = new Thread(t);
    		Thread t2 = new Thread(t);
    		
    		t0.start();
    		t1.start();
    		t2.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]

#### 同步方法-静态 ####

package cn.itcast.demo33;
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     * 
     * A 同步方法
     * 采用同步方法形式,解决线程的安全问题
     * 好处：代码简洁
     * 将线程共享数据,和同步,抽取到一个方法中
     * 在方法的声明上,加入同步关键字
     * 
     * 问题：
     * 	  同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
     *   如果方法是静态呢,同步有锁,绝对不是this
     *   锁是本类自己.class属性
     *   静态方法,同步锁,是本类类名.class属性
     */
    public class Tickets implements Runnable{
    	//StringBuffer
    	//StringBuilder
    	//定义票的票源
    	private static int ticket = 3;
    	//连对象都不需要使用了
    	//private Object obj = new Object();
    	
    	public void run(){
    		while(true){
    			payTicket();
    		}
    	}
    	//同步方法-静态
    	//如果方法是静态呢,同步有锁,绝对不是this
    	public static synchronized void payTicket(){
    		//对票数判断,大于0,可以出售,变量--操作
    		if(ticket > 0){
    			try {
    				Thread.sleep(10);//加了休眠让其他线程执行机会
    			} catch (InterruptedException e) {				
    				e.printStackTrace();
    			}
    			//ticket-- 先打印ticket,在对变量ticket减减
    			System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    		}			
    	}
    	
    	//静态方法,同步锁,是本类类名.class属性
    //	public static void payTicket(){
    //		//线程共享数据,保证安全,加入同步代码块
    //		//synchronized (this)  this=>t
    //		//synchronized (Tickets.class) ==>  锁是本类自己.class属性 与后面类的加载、反射有关
    //		synchronized (Tickets.class) {
    //			//对票数判断,大于0,可以出售,变量--操作
    //			if(ticket > 0){
    //				try {
    //					Thread.sleep(10);//加了休眠让其他线程执行机会
    //				} catch (InterruptedException e) {				
    //					e.printStackTrace();
    //				}
    //				//ticket-- 先打印ticket,在对变量ticket减减
    //				System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    //			}			
    //		}		
    //	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]

## 08JDK1.5新特性Lock接口 ##

### A:JDK1.5新特性Lock接口 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]  
查阅API，查阅Lock接口描述，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。  
 Lock接口中的常用方法  
void lock()  
void unlock()  
Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。  
我们使用Lock接口,以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket

## 09Lock接口改进售票案例 ##

package cn.itcast.demo4;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /*
     * 通过线程休眠,出现安全问题
     * 解决安全问题,Java程序,提供技术,同步技术
     * 公式：
     * 		synchronized(任意对象){
     * 			线程要操作的共享数据
     * 		}
     * 		同步代码块
     * 
     * A 同步方法
     * 采用同步方法形式,解决线程的安全问题
     * 好处：代码简洁
     * 将线程共享数据,和同步,抽取到一个方法中
     * 在方法的声明上,加入同步关键字
     * 
     * 问题：
     * 	  同步方法有锁嘛,肯定有,同步方法中的对象锁,是本类对象引用this
     *   如果方法是静态呢,同步有锁,绝对不是this
     *   锁是本类自己.class属性
     *   静态方法,同步锁,是本类类名.class属性
     *   
     *  使用JDK1.5 的接口Lock,替换同步代码块,实现线程的安全性
     *  Lock接口方法：
     *  	lock()获取锁
     *  	unlock()释放锁
     *  实现类ReentranLock
     */
    public class Tickets implements Runnable{
    	//定义票的票源
    	private int ticket = 2;
    	//在类的成员位置,创建Lock接口的实现类对象
    	private Lock lock = new ReentrantLock();
    	
    	public void run(){
    		while(true){
    			//调用Lock接口方法lock获取锁
    			lock.lock();
    			//对票数判断,大于0,可以出售,变量--操作
    			if(ticket > 0){
    				try {
    					Thread.sleep(10);
    					//ticket-- 先打印ticket,在对变量ticket减减
    					System.out.println(Thread.currentThread().getName() + "出售第 " + ticket--);
    				} catch (InterruptedException e) {
    					
    					e.printStackTrace();
    				}finally {
    					//释放锁,调用Lock接口方法unlock
    					lock.unlock();
    				}
    			}
    		}
    	}
    
    }

package cn.itcast.demo4;
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//创建Runnable接口实现类对象
    		Tickets t = new Tickets();
    		//创建3个Thread类对象,传递Runnable接口实现类
    		Thread t0 = new Thread(t);
    		Thread t1 = new Thread(t);
    		Thread t2 = new Thread(t);
    		
    		t0.start();
    		t1.start();
    		t2.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]

## 10线程的死锁原理 ##

### A:线程的死锁原理 ###

当线程任务中出现了多个同步(多个锁)  时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，
     这种现象我们称为死锁。这种情况能避免就 避免掉。
        synchronzied(A锁){
            synchronized(B锁){
    
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]

package cn.itcast.demo5;
    
    public class LockA {
    	private LockA(){}
    	
    	public static final LockA locka = new LockA();
    }

package cn.itcast.demo5;
    
    public class LockB {
    	private LockB(){}
    	
    	public static final LockB lockb = new LockB();
    }

package cn.itcast.demo5;
    //线程的死锁代码实现
    
    public class DeadLock implements Runnable{
    	private int i = 0;
    	public void run(){
    		while(true){
    			if(i%2==0){
    				//先进入A同步,再进入B同步
    				synchronized (LockA.locka) {
    					System.out.println("if...locka");
    					synchronized (LockB.lockb) {
    						System.out.println("if...lockb");
    					}
    				}
    			}else{
    				//先进入B同步,再进入A同步
    				synchronized (LockB.lockb) {
    					System.out.println("else...lockb");
    					synchronized (LockA.locka) {
    						System.out.println("else...lockb");
    					}
    				}
    			}
    			i++;
    		}
    	}
    }

package cn.itcast.demo5;
    
    public class DeadLockDemo {
    	public static void main(String[] args) {
    		DeadLock dead = new DeadLock();
    		Thread t0 = new Thread(dead);
    		Thread t1 = new Thread(dead);
    		
    		t0.start();
    		t1.start();
    	}
    }

结果不是很重要，主要是，开启两个线程，不断抢夺cpu资源，最终会有一次两个线程各抢夺一个钥匙，导致死锁  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]

## 12线程等待与唤醒案例介绍 ##

### A:线程等待与唤醒案例介绍 ###

等待唤醒机制所涉及到的方法：
         wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。
         notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
         notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。
       其实，所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用
       时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。

## 14线程等待与唤醒案例null值解决 ##

打印成员变量默认值null  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]

package cn.itcast.demo6;
    /*
     * 输入的线程,对资源对象Resource中成员变量赋值
     * 一次赋值 张三,男
     * 下次赋值  lisi,nv
     */
    public class Input implements Runnable {
    	//共享数据
    	private Resource r = new Resource();
    	
    	@Override
    	public void run() {
    		int i = 0;
    		while(true){
    			if(i%2 == 0){
    				r.name = "张三";
    				r.sex = "男";				
    			}else{
    				r.name = "lisi";
    				r.sex = "nv";				
    			}
    			i++;
    		}
    	}
    
    }

package cn.itcast.demo6;
    /*
     * 输出线程
     * 对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
    	private Resource r = new Resource();
    	@Override
    	public void run() {
    		while(true){
    			System.out.println(r.name + "..." + r.sex);
    		}
    	}
    
    }

package cn.itcast.demo6;
    /*
     * 定义资源类,有2个成员变量
     * name,sex
     * 同时有2个线程,对资源中的变量操作
     * 1个对name,sex赋值
     * 2个对name,sex变量输出打印
     */
    public class Resource {
    	public String name;
    	public String sex;
    }

package cn.itcast.demo6;
    /*
     * 开启输入输出线程,实现赋值和打印值
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		Input in = new Input();
    		Output out = new Output();
    		
    		Thread tin = new Thread(in);
    		Thread tout = new Thread(out);
    		
    		tin.start();
    		tout.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]

## 14人妖问题 ##

![人妖问题产生][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]

package cn.itcast.demo6;
    /*
     * 输入的线程,对资源对象Resource中成员变量赋值
     * 一次赋值 张三,男
     * 下次赋值  lisi,nv
     */
    public class Input implements Runnable {
    	//共享数据
    	private Resource r;
    	public Input(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		int i = 0;
    		while(true){
    			if(i%2 == 0){
    				r.name = "张三";
    				r.sex = "男";				
    			}else{
    				r.name = "lisi";
    				r.sex = "nv";				
    			}
    			i++;
    		}
    	}
    
    }

package cn.itcast.demo6;
    /*
     * 输出线程
     * 对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
    	private Resource r;
    	public Output(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		while(true){
    			System.out.println(r.name + "..." + r.sex);
    		}
    	}
    
    }

package cn.itcast.demo6;
    /*
     * 开启输入输出线程,实现赋值和打印值
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//new好，保证同一个,分别传给Input  Output
    		Resource r = new Resource();
    		
    		Input in = new Input(r);
    		Output out = new Output(r);
    		
    		Thread tin = new Thread(in);
    		Thread tout = new Thread(out);
    		
    		tin.start();
    		tout.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 21]

## 15 加同步，为何依然没有解决,需要两方面分析问题： ##

#### 1.所有的共享数据是否都加了同步锁 ####

#### 2.两个同步是不是用的同一把锁（上厕所问题） ####

package cn.itcast.demo6;
    /*
     * 输入的线程,对资源对象Resource中成员变量赋值
     * 一次赋值 张三,男
     * 下次赋值  lisi,nv
     */
    public class Input implements Runnable {
    	//共享数据
    	private Resource r;
    	public Input(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		int i = 0;
    		while(true){
    			//synchronized (this) 这里的this是Input的本类对象引用
    			//synchronized (r)对象资源锁,是统一外面赋值的，给两个线程的,是同一个对象
    			//保证锁的唯一性
    			synchronized (this) {
    				if(i%2 == 0){
    					r.name = "张三";
    					r.sex = "男";				
    				}else{
    					r.name = "lisi";
    					r.sex = "nv";				
    				}				
    			}
    			i++;
    		}
    	}
    
    }

package cn.itcast.demo6;
    /*
     * 输出线程
     * 对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
    	private Resource r;
    	public Output(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		while(true){
    			//synchronized (this) 这里的this是Output的本类对象引用
    			synchronized (this) {
    				System.out.println(r.name + "..." + r.sex);				
    			}
    		}
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 22]

## 16人妖问题解决：采用同一把锁 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 23]

package cn.itcast.demo6;
    /*
     * 输入的线程,对资源对象Resource中成员变量赋值
     * 一次赋值 张三,男
     * 下次赋值  lisi,nv
     */
    public class Input implements Runnable {
    	//共享数据
    	private Resource r;
    	public Input(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		int i = 0;
    		while(true){
    			//synchronized (this) 这里的this是Input的本类对象引用
    			//synchronized (r)对象资源锁,是统一外面赋值的，给两个线程的,是同一个对象
    			//保证锁的唯一性
    			synchronized (r) {
    				if(i%2 == 0){
    					r.name = "张三";
    					r.sex = "男";				
    				}else{
    					r.name = "lisi";
    					r.sex = "nv";				
    				}				
    			}
    			i++;
    		}
    	}
    
    }

package cn.itcast.demo6;
    /*
     * 输出线程
     * 对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
    	private Resource r;
    	public Output(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		while(true){
    			//synchronized (this) 这里的this是Output的本类对象引用
    			synchronized (r) {
    				System.out.println(r.name + "..." + r.sex);				
    			}
    		}
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 24]

## 17线程等待与唤醒案例通信的分析 ##

### A:线程等待与唤醒案例通信的分析 ###

输入:赋值后,执行方法wait()永远等待
    输出:变量值打印输出,在输出等待之前,唤醒
    输入的notify(),自己在wait()永远等待
    输入:被唤醒后,重新对变量赋值,赋值后,必须唤醒输出的线程notify(),
         自己的wait()

## 18线程等待与唤醒案例的实现 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 25]

package cn.itcast.demo7;
    /*
     * 定义资源类,有2个成员变量
     * name,sex
     * 同时有2个线程,对资源中的变量操作
     * 1个对name,sex赋值
     * 2个对name,sex变量输出打印
     */
    public class Resource {
    	public String name;
    	public String sex;//public String sex;
    	boolean flag = false;//标记
    }

package cn.itcast.demo7;
    /*
     * 输入的线程,对资源对象Resource中成员变量赋值
     * 一次赋值 张三,男
     * 下次赋值  lisi,nv
     */
    public class Input implements Runnable {
    	//共享数据
    	private Resource r;
    	public Input(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		int i = 0;
    		while(true){
    			//synchronized (this) 这里的this是Input的本类对象引用
    			//synchronized (r)对象资源锁,是统一外面赋值的，给两个线程的,是同一个对象
    			//保证锁的唯一性
    			synchronized (r) {
    				//标记判断:true-完成赋值,等待
    				if(r.flag){
    					try {wait();} catch (InterruptedException e) {}
    				}
    				if(i%2 == 0){
    					r.name = "张三";
    					r.sex = "男";				
    				}else{
    					r.name = "lisi";
    					r.sex = "nv";				
    				}
    				//将对方唤醒,标记改为true
    				r.flag = true;
    				notify();//方法是Object类的,随时可以调用
    			}
    			i++;
    		}
    	}
    
    }

package cn.itcast.demo7;
    /*
     * 输出线程
     * 对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
    	private Resource r;
    	public Output(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		while(true){
    			//synchronized (this) 这里的this是Output的本类对象引用
    			synchronized (r) {
    				//标记判断：flase-获取值完成,等待
    				if(!r.flag){
    					try {wait();} catch (InterruptedException e) {}
    				}
    				System.out.println(r.name + "..." + r.sex);	
    				//将标记修改成false,唤醒对方线程
    				r.flag = false;
    				notify();
    			}
    		}
    	}
    
    }

package cn.itcast.demo7;
    /*
     * 开启输入输出线程,实现赋值和打印值
     */
    public class ThreadDemo {
    	public static void main(String[] args) {
    		//new好，保证同一个,分别传给Input  Output
    		Resource r = new Resource();
    		
    		Input in = new Input(r);
    		Output out = new Output(r);
    		
    		Thread tin = new Thread(in);
    		Thread tout = new Thread(out);
    		
    		tin.start();
    		tout.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 26]  
![\*\*加粗样式\*\*][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 27]

## 19必须锁对象调用唤醒等待，而不是父类 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 28]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 29]

package cn.itcast.demo7;
    /*
     * 输入的线程,对资源对象Resource中成员变量赋值
     * 一次赋值 张三,男
     * 下次赋值  lisi,nv
     */
    public class Input implements Runnable {
    	//共享数据
    	private Resource r;
    	public Input(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		int i = 0;
    		while(true){
    			//synchronized (this) 这里的this是Input的本类对象引用
    			//synchronized (r)对象资源锁,是统一外面赋值的，给两个线程的,是同一个对象
    			//保证锁的唯一性
    			synchronized (r) {
    				//标记判断:true-完成赋值,等待
    				if(r.flag){
    					try {r.wait();} catch (InterruptedException e) {}
    				}
    				if(i%2 == 0){
    					r.name = "张三";
    					r.sex = "男";				
    				}else{
    					r.name = "lisi";
    					r.sex = "nv";				
    				}
    				//将对方唤醒,标记改为true
    				r.flag = true;
    				r.notify();//方法是Object类的,随时可以调用
    			}
    			i++;
    		}
    	}
    
    }

package cn.itcast.demo7;
    /*
     * 输出线程
     * 对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
    	private Resource r;
    	public Output(Resource r){
    		this.r = r;
    	}
    	@Override
    	public void run() {
    		while(true){
    			//synchronized (this) 这里的this是Output的本类对象引用
    			synchronized (r) {
    				//标记判断：flase-获取值完成,等待
    				if(!r.flag){
    					try {r.wait();} catch (InterruptedException e) {}
    				}
    				System.out.println(r.name + "..." + r.sex);	
    				//将标记修改成false,唤醒对方线程
    				r.flag = false;
    				r.notify();
    			}
    		}
    	}
    
    }

#### 输出; ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 30]

lisi...nv
    张三...男
    lisi...nv
    张三...男
    lisi...nv
    张三...男
    lisi...nv
    张三...男
    lisi...nv
    张三...男
    lisi...nv
    张三...男
    lisi...nv
    张三...男
    lisi...nv
    张三...男

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220404/d0e8a2399f7644aabfbaf3a571656289.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220404/b6db1093c8af45dda2136067fcbf0780.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220404/ad614734ecc84facb1a50913fea8b372.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220404/2012c62226084e3898b04a295df60c31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220404/ab261bd1dc7a4594b7ad3c15fae73cfd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220404/7b5e25ba6dd4430e9e463c6462160e7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220404/dcecb4a4f12946a78d70ad1ad843d7fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220404/b06cec8305bc42abbe6c6b29db87e33a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220404/221636f571274808b9890601dc980858.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220404/dcbe4d20b2ad4523bb21a9d9c6e17345.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220404/6b3ecde9c2fb4b979e141476d564cb80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220404/8276d5ff0e854d2e96fa14d21ea9a886.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220404/20a93eeebdcd491d8dd6cedc4bcba758.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220404/b8775625399849c8bea03dae6a8ed88f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220404/921b38aaf07647afb8f4565bbb6df06b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]: /images/20220404/0bdd0fc5c3484ad39133deb47136c88e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]: /images/20220404/b36567ebcc8b4f06ab73518d3ff60c4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]: /images/20220404/115629e50477461eb09455374b514847.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]: /images/20220404/f311b654c14247c1b3f3f2f4e23a0a3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]: /images/20220404/85dbd2258c704010ba0974b285c1cbb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]: /images/20220404/f7e0116886884cec8b2efd2c966caf7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 21]: /images/20220404/7b3b4c8c1fe14a8e8afc22484623e723.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 22]: /images/20220404/59cb2e52170c43aba51efaf5b42b4328.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 23]: /images/20220404/6afe260c87454d54a713c1575b576d9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 24]: /images/20220404/82849a5a328646acb132d23d7216fdea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 25]: /images/20220404/870a0bb1cd52478a9d68ee2b28733843.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 26]: /images/20220404/70edb3fe94f546dea8a9230a6afa1648.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 27]: /images/20220404/d3fc37a250af4324b18f9feac99a1e25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 28]: /images/20220404/144f4defe45f48dca95abf72fb0fac38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 29]: /images/20220404/21ede9c4d3ec445482a5d6726726dcc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 30]: /images/20220404/f995ebd245964ff7b5157725b607dc35.png