同步锁-线程安全问题解决方案

1 同步锁

1.1 前言

经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.
上节笔记点这里-进程与线程笔记

我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件:

在多线程程序中 + 有共享数据 + 多条语句操作共享数据

多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
那我们可以把有可能出现问题的代码都包裹起来,一次只让一个线程来执行

1.2 同步与异步

那怎么"把有可能出现问题的代码都包裹起来"呢?我们可以使用同步锁-线程安全问题解决方案

1.4 练习-改造售票案例

创建包: cn.tedu.thread
创建类:TestSaleTicketsV2.java

package cn.tedu.thread; /**  * 本类用于改造售票案例,解决多线程编程安全问题  * 需求:4个线程共同卖100张票  * 问题1:出现了重卖现象:一张票卖给了多个人  * 问题2:出现了超卖现象:出现了0张/-1张/-2张这样的现象  * */ public class TestSaleTicketsV2 { 	public static void main(String[] args) { 		//5.创建接口实现类对象作为目标对象(目标对象就是要做的业务) 		SaleTicketsV2 target = new SaleTicketsV2(); 		//6.将目标对象与Thread线程对象绑定 		Thread t1 = new Thread(target); 		Thread t2 = new Thread(target); 		Thread t3 = new Thread(target); 		Thread t4 = new Thread(target); 		//7.以多线程的方式启动线程--会将线程由新建状态变为就绪状态 		/**1.如果只创建了一个线程对象,是单线程场景,不会出现数据问题*/ 		t1.start(); 		t2.start(); 		t3.start(); 		t4.start(); 	} } /**2.多线程中出现数据不安全问题的前提:多线程程序 + 有共享数据(成员变量) +多条语句操作共享数据*/ /**3.同步锁:相当于给容易出现问题的代码加了一把锁,包裹了所有可能会出现问题的代码  * 加锁范围:不能太大,也不能太小,太大,干啥都得排队,导致程序的效率太低,太小,没锁住,会有安全问题*/ //1.自定义售票类,通过实现Runnable接口的方式完成 class SaleTicketsV2 implements Runnable{ 	//2.定义静态成员变量,用来保存票数 	static int tickets = 100; 	//9.2创建了一个唯一的"锁"对象,不论之后那个线程进同步代码块,使用的都是o对象,"唯一"很重要 	Object o = new Object(); 	 	/**6.如果一个方法里的代码都被同步了,可以直接把方法修饰成同步方法,同步方法用的锁对象是this*/ 	//3.添加未实现方法run()--写业务 	@Override 	//synchronized public void run() {//被synchronized修饰的方法是同步方法 	public void run() {//被synchronized修饰的方法是同步方法 		//4.1通过while(true)死循环的方式卖票,注意添加出口!!! 		while(true) { 			/**4.synchronized(锁对象){}--同步代码块:是指同一时间这一资源会被一个线程独享,大家使用的时候,都得排队,同步效果*/ 			/**5.锁对象的要求:多线程之间必须使用同一把锁,同步代码块的方式,关于锁对象可以任意定义*/ 			//9.出现了线程安全问题,所以需要加同步代码块 			//9.1这种写法不对,相当于每个线程进来一次new一个锁对象,并不是使用的同一把锁 		    //synchronized (new Object()) {			 		    //9.3 使用同步代码块,锁对象是o 			synchronized (o) { 				//4.2通过if结构判断卖票情况 				if(tickets > 0) {//还有票,继续售卖 					//8.手动添加休眠方法,创造延迟效果,注意可能会发生问题,需要由try-catch包裹 					try { 						Thread.sleep(10);//让线程休眠10ms 					} catch (InterruptedException e) { 						e.printStackTrace(); 					} 					//4.3打印当前卖票的线程名以及票数 					System.out.println(Thread.currentThread().getName() + "=" + tickets--); 				} 				//4.4 没票了,退出循环,没的卖了 				if(tickets <= 0) break; 			} 		} 	} }  

1.5 之前遇到过的同步例子

StringBuffer JDK1.0
加了synchronized ,性能相对较低(要排队,同步),安全性高
StringBuilder JDK1.5
去掉了synchronized,性能更高(不排队,异步),存在安全隐患
同步锁-线程安全问题解决方案

快速查找某个类的快捷键:Ctrl+Shift+T

2 线程创建的其他方式

2.1 ExecutorService/Executors

ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理

  • execute(Runnable任务对象) 把任务丢到线程池

Executors 辅助创建线程池的工具类

  • newFixedThreadPool(int nThreads) 最多n个线程的线程池
  • newCachedThreadPool() 足够多的线程,使任务不必等待
  • newSingleThreadExecutor() 只有一个线程的线程池

2.2 练习:线程的其他创建方式

创建包: cn.tedu.thread
创建类: TestSaleTicketsV2.java

public class TestSaleTicketsV2 { 	public static void main(String[] args) { 		//5.创建接口实现类对象作为目标对象(目标对象就是要做的业务) 		SaleTicketsV2 target = new SaleTicketsV2(); 		//6.将目标对象与Thread线程对象绑定 //		Thread t1 = new Thread(target); //		Thread t2 = new Thread(target); //		Thread t3 = new Thread(target); //		Thread t4 = new Thread(target); 		//7.以多线程的方式启动线程--会将线程由新建状态变为就绪状态 		/**1.如果只创建了一个线程对象,是单线程场景,不会出现数据问题*/ //		t1.start(); //		t2.start(); //		t3.start(); //		t4.start(); 		/**7.线程池ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理*/ 		/**8.Executors用来辅助创建线程池对象,newFixedThreadPool()创建具有参数个数的线程数的线程池*/ 		ExecutorService pool = Executors.newFixedThreadPool(5); 		for(int i = 0;i<5;i++) { 			/**9.excute()让线程池中的线程来执行任务,每次调用都会启动一个线程*/ 			pool.execute(target);//本方法的参数就是执行的业务,也就是实现类的目标对象 		} 	} 

3 拓展:线程锁

3.1 悲观锁和乐观锁

悲观锁:像它的名字一样,对于并发间操作产生的线程安全问题持悲观状态.
悲观锁认为竞争总是会发生,因此每次对某资源进行操作时,都会持有一个独占的锁,就像synchronized,不管三七二十一,直接上了锁就操作资源了。

乐观锁:还是像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态.
乐观锁认为竞争不总是会发生,因此它不需要持有锁,将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量,如果失败则表示发生冲突,那么就应该有相应的重试逻辑。

3.2 两种常见的锁

synchronized 互斥锁(悲观锁,有罪假设)

采用synchronized修饰符实现的同步机制叫做互斥锁机制,它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记),当线程拥有这个锁标记时才能访问这个资源,没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁,这个锁是为了分配给线程的,防止打断原子操作。每个对象的锁只能分配给一个线程,因此叫做互斥锁。

ReentrantLock 排他锁(悲观锁,有罪假设)

ReentrantLock是排他锁,排他锁在同一时刻仅有一个线程可以进行访问,实际上独占锁是一种相对比较保守的锁策略,在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生,这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题,如果”读/读”操作能够以共享锁的方式进行,那会进一步提升性能。

ReentrantReadWriteLock 读写锁(乐观锁,无罪假设)

因此引入了ReentrantReadWriteLock,顾名思义,ReentrantReadWriteLock是Reentrant(可重入)Read(读)Write(写)Lock(锁),我们下面称它为读写锁。
读写锁内部又分为读锁和写锁,读锁可以在没有写锁的时候被多个线程同时持有,写锁是独占的。
读锁和写锁分离从而提升程序性能,读写锁主要应用于读多写少的场景。

3.3 尝试用读写锁改造售票案例

package cn.tedu.thread;  import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.ReentrantReadWriteLock;  /**  * 本类用于改造售票案例,使用可重入读写锁  * ReentrantReadWriteLock  * */ public class TestSaleTicketsV3 { 	public static void main(String[] args) { 		SaleTicketsV3 target = new SaleTicketsV3(); 		Thread t1 = new Thread(target); 		Thread t2 = new Thread(target); 		Thread t3 = new Thread(target); 		Thread t4 = new Thread(target); 		t1.start(); 		t2.start(); 		t3.start(); 		t4.start(); 	} } class SaleTicketsV3 implements Runnable{ 	static int tickets = 100; 	//1.定义可重入读写锁对象,静态保证全局唯一 	static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); 	@Override 	public void run() { 		while(true) { 			//2.在操作共享资源前上锁 			lock.writeLock().lock(); 			try { 				if(tickets > 0) { 					try { 						Thread.sleep(10); 					} catch (InterruptedException e) { 						e.printStackTrace(); 					} 					System.out.println(Thread.currentThread().getName() + "=" + tickets--); 				} 				if(tickets <= 0) break; 			} catch (Exception e) { 				e.printStackTrace(); 			}finally { 				//3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了 				lock.writeLock().unlock(); 			} 		} 	} }  

3.4 两种方式的区别

需要注意的是,用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放,而是用Lock需要我们手动释放锁,所以为了保证锁最终被释放(发生异常情况),要把互斥区放在try内,释放锁放在finally内!
与互斥锁相比,读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(writer 线程)可以修改共享数据,但在许多情况下,任何数量的线程可以同时读取共享数据(reader 线程)从理论上讲,与互斥锁定相比,使用读-写锁允许的并发性增强将带来更大的性能提高。

恭喜你,线程与线程锁的学习可以暂时告一段落啦,接着我们可以继续学习别的内容

下一节 设计模式 点这里

版权声明:玥玥 发表于 2021-03-23 11:25:33。
转载请注明:同步锁-线程安全问题解决方案 | 女黑客导航