JavaSE|线程安全

柔光的暖阳◎ 2022-04-10 13:21 249阅读 0赞

### JavaSE|线程安全 ###

*  案例与线程安全
 *   *  两种方式实现模拟电影院售票
     *  增加售票延迟
     *  解决线程安全问题的基本思想
 *  同步：解决线程安全问题
 *   *  解决线程安全问题实现1
     *  同步的特点
     *  解决线程安全问题实现2
     *  线程安全的类
 *  JDK5中Lock锁的使用
 *  死锁
 *  生产者-消费者问题
 *   *  线程间通信
     *  等待唤醒机制
     *  线程的状态转换图
     *  代码改进

# 案例与线程安全 #

## 两种方式实现模拟电影院售票 ##

需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。

两种方式实现：

1.  继承Thread类
2.  实现Runnable接口

// 继承Thread类的方式
    public class SellTicketDemo {
        
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
        
    		SellTicket st1 = new SellTicket();
    		SellTicket st2 = new SellTicket();
    		SellTicket st3 = new SellTicket();
    		
    		st1.setName("窗口1");
    		st2.setName("窗口2");
    		st3.setName("窗口3");
    		
    		st1.start();
    		st2.start();
    		st3.start();
    
    	}
    
    }
    
    public class SellTicket extends Thread {
        
    	
    	// 此处一定要用static，共享数据
    	private static int ticket = 100;
    
    	@Override
    	public void run() {
        
    		while(true){
        
    			if(ticket > 0){
        
    				System.out.println(getName() + "正在售卖第" + (ticket--) + "张票");
    			}
    		}
    	}
    }

// 实现Runnable接口方式
    public class SellTicketDemo {
        
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
        
    
    		SellTicket st = new SellTicket();
    		
    		Thread t1 = new Thread(st, "窗口1");
    		Thread t2 = new Thread(st, "窗口2");
    		Thread t3 = new Thread(st, "窗口3");
    		
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    
    public class SellTicket implements Runnable{
        
    
    	private int ticket = 100;
    	@Override
    	public void run() {
        
    		while(true){
        
    			if(ticket > 0){
        
    				System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
    			}
    		}
    		
    	}
    }

实现Runnable接口的方式比继承Thread类的方式更适合这个案例。三个售票窗口共享同一个剩余票数，使用Thread类时，由于需要创建三个Thread实例，所以必须将剩余票数设置为static的成员变量。而实现Runnable接口的方式中只有一个实现Runnable接口的实例，即共享的数据本来就只有一份，将数据有效分离，代码更优雅。

## 增加售票延迟 ##

电影院售票程序，从表面上看不出什么问题，但是在真实生活中，售票时网络是不能实时传输的，总是存在延迟的情况，所以，在出售一张票以后，需要一点时间的延迟。  
需求：改实现接口方式的卖票程序，每次卖票延迟100毫秒。

public class SellTicketDemo {
        
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
        
    
    		SellTicket st = new SellTicket();
    		
    		Thread t1 = new Thread(st, "窗口1");
    		Thread t2 = new Thread(st, "窗口2");
    		Thread t3 = new Thread(st, "窗口3");
    		
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    
    public class SellTicket implements Runnable{
        
    
    	private int ticket = 100;
    	@Override
    	public void run() {
        
    		while(true){
        
    			if(ticket > 0){
        
    				try {
        
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
        
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
    			}
    		}
    		
    	}
    }

相同的票出现多次：  
![在这里插入图片描述][20190104181928740.png]  
出现负数结果：  
![在这里插入图片描述][2019010417583826.png]

加入延迟后，我们发现出现了两个问题：

1.  **相同的票出现多次**  
    CPU的一次操作必须是原子性的
2.  **还出现了负数的票**  
    随机性和延迟导致的

注意：  
线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

## 解决线程安全问题的基本思想 ##

**首先想为什么出现问题?(也是我们判断是否有问题的标准)**

*  是否是多线程环境
 *  是否有共享数据
 *  是否有多条语句操作共享数据

**如何解决多线程安全问题呢?**  
基本思想：让程序没有安全问题的环境。

**怎么实现呢?**  
把多个语句操作共享数据的代码给**锁起来**，让任意时刻只能有一个线程执行即可。

# 同步：解决线程安全问题 #

## 解决线程安全问题实现1 ##

即同步代码块。

格式：**synchronized(对象)\{需要同步的代码;\}**  
同步可以解决安全问题的根本原因就在那个**对象**上。该对象如同**锁**的功能。

**同步代码块的对象可以是哪些呢?**  
下面代码使用的Object，其实可以是**任意对象**，例如自定义的类等。

同步代码块用obj做锁：

public class SellTicketDemo {
        
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
        
    
    		SellTicket st = new SellTicket();
    		
    		Thread t1 = new Thread(st, "窗口1");
    		Thread t2 = new Thread(st, "窗口2");
    		Thread t3 = new Thread(st, "窗口3");
    		
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    public class SellTicket implements Runnable{
        
    
    	// 定义100张票
    	private int ticket = 100;
    	// 定义同一把锁
    	private Object obj = new Object();
    	@Override
    	public void run() {
        
    		while(true){
        
    			synchronized(obj){
        
    				if(ticket > 0){
        
    					try {
        
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
        
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
    				}
    			}
    		}
    		
    	}
    }

同步代码块用任意对象做锁：

public class SellTicket implements Runnable {
        
    
    	// 定义100张票
    	private static int tickets = 100;
    
    	// 定义同一把锁
    	private Demo d = new Demo();
    	
    	//同步代码块用任意对象做锁
    	@Override
    	public void run() {
        
    		while (true) {
        
    			synchronized (d) {
        
    				if (tickets > 0) {
        
    					try {
        
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
        
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName()
    							+ "正在出售第" + (tickets--) + "张票 ");
    				}
    			}
    		}
    	}
    	
    class Demo {
        
    }

## 同步的特点 ##

同步的前提：

*  多个线程
 *  多个线程使用的是同一个锁对象

同步的好处：同步的出现解决了多线程的安全问题。

同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

## 解决线程安全问题实现2 ##

即同步方法。

格式：把同步关键字加到**方法**上。

问题：

1.  **同步方法的锁对象**是什么呢?  
    this
2.  如果是**静态方法**，同步方法的锁对象又是什么呢?  
    类的字节码文件。
3.  那么，我们到底使用谁?  
    如果锁对象是this，就可以考虑使用同步方法。  
    否则能使用同步代码块的尽量使用同步代码块。

同步非静态方法，用this作锁：

public class SellTicket implements Runnable {
        
    
    	// 定义100张票
    	private static int tickets = 100;
    
    	// 定义同一把锁
    	private Object obj = new Object();
    
    
    	private int x = 0;
    	
    
    	@Override
    	public void run() {
        
    		while (true) {
        
    			if(x%2==0){
        
    				synchronized (this) {
        
    					if (tickets > 0) {
        
    						try {
        
    							Thread.sleep(100);
    						} catch (InterruptedException e) {
        
    							e.printStackTrace();
    						}
    						System.out.println(Thread.currentThread().getName()
    								+ "正在出售第" + (tickets--) + "张票 ");
    					}
    				}
    			}else {
        			
    				sellTicket();				
    			}
    			x++;
    		}
    	}
    
    
    	private synchronized void sellTicket() {
        
    		if (tickets > 0) {
        
    		try {
        
    				Thread.sleep(100);
    		} catch (InterruptedException e) {
        
    				e.printStackTrace();
    		}
    		System.out.println(Thread.currentThread().getName()
    					+ "正在出售第" + (tickets--) + "张票 ");
    		}
    }
    }

同步静态方法，用该类的字节码文件作锁：

public class SellTicket implements Runnable {
        
    
    	// 定义100张票
    	private static int tickets = 100;
    
    	// 定义同一把锁
    	private Object obj = new Object();
    
    
    	private int x = 0;
    	
    
    	@Override
    	public void run() {
        
    		while (true) {
        
    			if(x%2==0){
        
    				synchronized (SellTicket.class) {
        
    					if (tickets > 0) {
        
    						try {
        
    							Thread.sleep(100);
    						} catch (InterruptedException e) {
        
    							e.printStackTrace();
    						}
    						System.out.println(Thread.currentThread().getName()
    								+ "正在出售第" + (tickets--) + "张票 ");
    					}
    				}
    			}else {
        			
    				sellTicket();				
    			}
    			x++;
    		}
    	}
    
    
    	private static synchronized void sellTicket() {
        
    		if (tickets > 0) {
        
    		try {
        
    				Thread.sleep(100);
    		} catch (InterruptedException e) {
        
    				e.printStackTrace();
    		}
    		System.out.println(Thread.currentThread().getName()
    					+ "正在出售第" + (tickets--) + "张票 ");
    		}
    }
    }

## 线程安全的类 ##

StringBuffer、Vector、Hashtable都是线程安全的类，通过查看源码我们看到，类中几乎每一个方法都加了synchronized关键字。

Vector是线程安全的时候才去考虑使用的，但是即使要安全，也不用Vector，可以通过Collections集合的静态方法，得到线程安全的集合。例如：  
**public static List synchronizedList(List list)**

public class ThreadDemo {
        
    	public static void main(String[] args) {
        
    		// 线程安全的类
    		StringBuffer sb = new StringBuffer();
    		Vector<String> v = new Vector<String>();
    		Hashtable<String, String> h = new Hashtable<String, String>();
    
    		// Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
    		// 那么到底用谁呢?
    		// public static <T> List<T> synchronizedList(List<T> list)
    		List<String> list1 = new ArrayList<String>();// 线程不安全
    		List<String> list2 = Collections
    				.synchronizedList(new ArrayList<String>()); // 线程安全
    	}
    }

# JDK5中Lock锁的使用 #

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。

Lock是一个**接口**，使用的时候需要实例化为其**子类对象**。（如**ReentrantLock**是Lock的实现类）

Lock使用的一般格式：

Lock l = ...; 
         l.lock();
         try {
             // access the resource protected by this lock
         } finally {
             l.unlock();
         }

**void lock()**：获取锁。  
**void unlock()**：释放锁。

将Lock应用在电影院售票程序中如下：

public class SellTicketDemo {
        
    	public static void main(String[] args) {
        
    		// 创建资源对象
    		SellTicket st = new SellTicket();
    
    		// 创建三个窗口
    		Thread t1 = new Thread(st, "窗口1");
    		Thread t2 = new Thread(st, "窗口2");
    		Thread t3 = new Thread(st, "窗口3");
    
    		// 启动线程
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    
    public class SellTicket implements Runnable {
        
    
    	// 定义票
    	private int tickets = 100;
    
    	// 定义锁对象
    	private Lock lock = new ReentrantLock();
    
    	@Override
    	public void run() {
        
    		while (true) {
        
    			try {
        
    				// 加锁
    				lock.lock();
    				if (tickets > 0) {
        
    					try {
        
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
        
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName()
    							+ "正在出售第" + (tickets--) + "张票");
    				}
    			} finally {
        
    				// 释放锁
    				lock.unlock();
    			}
    		}
    	}
    
    }

# 死锁 #

同步弊端：1)效率低；2)如果出现了同步嵌套，就容易产生死锁问题  
死锁就是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种**互相等待**现象。

同步代码块的嵌套案例如下：

public class DieLockDemo {
        
    	public static void main(String[] args) {
        
    		DieLock dl1 = new DieLock(true);
    		DieLock dl2 = new DieLock(false);
    
    		dl1.start();
    		dl2.start();
    	}
    }
    
    public class MyLock {
        
    	// 创建两把锁对象
    	public static final Object objA = new Object();
    	public static final Object objB = new Object();
    }
    
    public class DieLock extends Thread {
        
    
    	private boolean flag;
    
    	public DieLock(boolean flag) {
        
    		this.flag = flag;
    	}
    
    	@Override
    	public void run() {
        
    		if (flag) {
        
    			synchronized (MyLock.objA) {
        
    				System.out.println("if objA");
    				synchronized (MyLock.objB) {
        
    					System.out.println("if objB");
    				}
    			}
    		} else {
        
    			synchronized (MyLock.objB) {
        
    				System.out.println("else objB");
    				synchronized (MyLock.objA) {
        
    					System.out.println("else objA");
    				}
    			}
    		}
    	}
    }

# 生产者-消费者问题 #

## 线程间通信 ##

针对同一个资源的操作有不同种类的线程。  
举例：卖票有进的，也有出的。

案例：通过**设置线程(生产者)和获取线程(消费者)针对同一个学生对象**进行操作。

## 等待唤醒机制 ##

**Object类**中提供了三个方法：  
**wait()**：等待。等待的时候会**立即释放锁**。将来醒过来的时候，是从该语句位置醒来，即**从该位置继续执行**。  
**notify()**：唤醒单个线程。唤醒并不意味着被唤醒的进程可以立马执行，还是需要**抢CPU执行权**。  
**notifyAll()**：唤醒所有线程。（用在多生产多消费中）

问题：为什么这些方法不定义在Thread类中呢?  
这些方法的调用必须通过**锁对象**调用，而我们刚才使用的锁对象是**任意**锁对象。  
所以，这些方法必须定义在Object类中。

/*
     * 分析：
     * 		资源类：Student	
     * 		设置学生数据:SetThread(生产者)
     * 		获取学生数据：GetThread(消费者)
     * 		测试类:StudentDemo
     * 
     * 问题1：按照思路写代码，发现数据每次都是:null---0
     * 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
     * 如何实现呢?
     * 		在外界把这个数据创建出来，通过构造方法传递给其他的类。
     * 
     * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
     * 		A:同一个数据出现多次
     * 		B:姓名和年龄不匹配
     * 原因：
     * 		A:同一个数据出现多次
     * 			CPU的一点点时间片的执行权，就足够你执行很多次。
     * 		B:姓名和年龄不匹配
     * 			线程运行的随机性
     * 线程安全问题：
     * 		A:是否是多线程环境		是
     * 		B:是否有共享数据		是
     * 		C:是否有多条语句操作共享数据	是
     * 解决方案：
     * 		加锁。
     * 		注意：
     * 			A:不同种类的线程都要加锁。
     * 			B:不同种类的线程加的锁必须是同一把。
     * 
     * 问题3:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
     * 如何实现呢?
     * 		通过Java提供的等待唤醒机制解决。
     * 
     * 等待唤醒：
     * 		Object类中提供了三个方法：
     * 			wait():等待
     * 			notify():唤醒单个线程
     * 			notifyAll():唤醒所有线程
     * 		为什么这些方法不定义在Thread类中呢?
     * 			这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
     * 			所以，这些方法必须定义在Object类中。
     */
    public class StudentDemo {
        
    	public static void main(String[] args) {
        
    		//创建资源
    		Student s = new Student();
    		
    		//设置和获取的类
    		SetThread st = new SetThread(s);
    		GetThread gt = new GetThread(s);
    
    		//线程类
    		Thread t1 = new Thread(st);
    		Thread t2 = new Thread(gt);
    
    		//启动线程
    		t1.start();
    		t2.start();
    	}
    }
    
    public class Student {
        
    	String name;
    	int age;
    	boolean flag; // 默认情况是没有数据，如果是true，说明有数据
    }
    
    public class SetThread implements Runnable {
        
    
    	private Student s;
    	private int x = 0;
    
    	public SetThread(Student s) {
        
    		this.s = s;
    	}
    
    	@Override
    	public void run() {
        
    		while (true) {
        
    			synchronized (s) {
        
    				//判断有没有
    				if(s.flag){
        
    					try {
        
    						s.wait(); //t1等着，释放锁
    					} catch (InterruptedException e) {
        
    						e.printStackTrace();
    					}
    				}
    				
    				if (x % 2 == 0) {
        
    					s.name = "林青霞";
    					s.age = 27;
    				} else {
        
    					s.name = "刘意";
    					s.age = 30;
    				}
    				x++; //x=1
    				
    				//修改标记
    				s.flag = true;
    				//唤醒线程
    				s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
    			}
    			//t1有，或者t2有
    		}
    	}
    }
    
    public class GetThread implements Runnable {
        
    	private Student s;
    
    	public GetThread(Student s) {
        
    		this.s = s;
    	}
    
    	@Override
    	public void run() {
        
    		while (true) {
        
    			synchronized (s) {
        
    				if(!s.flag){
        
    					try {
        
    						s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候，是从这里醒过来的时候
    					} catch (InterruptedException e) {
        
    						e.printStackTrace();
    					}
    				}
    				
    				System.out.println(s.name + "---" + s.age);
    				//林青霞---27
    				//刘意---30
    				
    				//修改标记
    				s.flag = false;
    				//唤醒线程
    				s.notify(); //唤醒t1
    			}
    		}
    	}
    }

## 线程的状态转换图 ##

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

## 代码改进 ##

在目前书写的消费者-生产者代码中，学生资源类的属性都是默认的，在实际书写中一般将其用private修饰，所以此处改进。同时由于用private修饰了属性，在类外我们就不能直接对其操作了，应该在Student类中提供相应的Set()和Get()方法。那么这个时候应该怎么同步呢？怎么样才能达到我们预期的效果？（即生产一个消费一个依次循环）

public class StudentDemo {
        
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
        
    
    		Student s = new Student();
    		SetThread st = new SetThread(s);
    		GetThread gt = new GetThread(s);
    		
    		Thread t1 = new Thread(st);
    		Thread t2 = new Thread(gt);
    		
    		t1.start();
    		t2.start();	
    
    	}
    }
    
    // 学生资源类
    public class Student {
        
    	
    	private String name;
    	private int age;
    	private boolean flag;
    	
    	public Student() {
        
    
    	}
    
    	public synchronized void Set(String name, int age){
        
    		if(this.flag){
        
    			try {
        
    				this.wait();
    			} catch (InterruptedException e) {
        
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		this.name = name;
    		this.age = age;
    		
    		this.flag = true;
    		this.notify();
    		
    	}
    	
    	public synchronized void Get(){
        
    		if(!this.flag){
        
    			try {
        
    				this.wait();
    			} catch (InterruptedException e) {
        
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		System.out.println(name + "---" + age);
    		this.flag = false;
    		this.notify();
    	}
    }
    
    // 生产者
    public class SetThread implements Runnable {
        
    
    	private int x = 0;
    	private Student s;
    	
    	public SetThread(Student s) {
        
    		this.s = s;
    	}
    
    	@Override
    	public void run() {
        
    		while(true){
        
    			if(x % 2 == 0){
        
    				s.Set("林青霞", 27);
    			}else{
        
    				s.Set("刘意", 30);
    			}
    			x++;
    		}
    	}
    }
    
    // 消费者
    public class GetThread implements Runnable {
        
    
    	private Student s;
    	
    	public GetThread(Student s) {
        
    		this.s = s;
    	}
    
    	@Override
    	public void run() {
        
    		while(true){
        
    			s.Get();
    		}
    	}
    }

在之前的实现中，我们是在SetThread（生产者）和GetThread（消费者）类中，对需要同步的代码块，使用Student对象，进行同步。现在我们可以直接在Student类中对其Set()和Get()方法使用同步关键字。要想达成生产一个消费一个效果，像之前一样，用flag结合等待唤醒机制即可。

[20190104181928740.png]: /images/20220330/c5c5af68b5524b15815d6b6c6c31db90.png
[2019010417583826.png]: /images/20220330/135599de31304cf0bb55a94945d93204.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhcmxpbmd3b29kMjAxMw_size_16_color_FFFFFF_t_70]: /images/20220330/8eb86579f47f4b8e949ecdc96dac2ecc.png