JAVA基础同步锁-线程安全问题的解决方案_同步锁是不是单线程-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40856602/article/details/118709333

1 同步锁

1.1 前言

在多线程中会遇到很多的线程安全问题
在多线程程序中 + 有共享数据 + 多条语句操作共享数据

1.2 同步与异步

同步：体现了排队的效果，同一时刻只能有一个线程独占资源，其他没有权利的线程排队。
坏处就是效率会降低，不过保证了安全。
异步：体现了多线程抢占资源的效果，线程间互相不等待，互相抢占资源。
坏处就是有安全隐患,效率要高一些。

1.3 sysnchronized同步关键字

1.3.1 写法

synchronized (锁对象){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}

1.3.2 前提

同步效果的使用有两个前提：

前提1：同步需要两个或者两个以上的线程（但线程无需考虑多线程安全问题）
前提2：多个线程间必须使用同一个锁（我上锁手其他人也能看到这个锁，不然我的锁锁不住其他人，就没有了上锁的效果）

1.3.3 特点

syschronized同步关键字用来修饰方法。称为同步方法，适用的锁对象是this
syschronized同步关键字可以修饰代码块，称为永不代码块，适用的锁对象可以任意
同步的缺点是会降低程序的执行效率，但为了保证线程的安全，有些性能是必须要牺牲的
但是为了性能，加锁的范需要控制好，范围越小越好

为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢?
因为同步代码块可以保证同一个时刻只有一个线程进入
但同步方法不可以保证同一时刻只能有一个线程调用,所以使用本类代指对象this来确保同步

1.4 之前遇到的例子

StringBuffer JDK1.0
加了synchronized ,性能相对较低(要排队,同步),安全性高
StringBuilder JDK1.5
去掉了synchronized,性能更高(不排队,异步),存在安全隐患

2 线程创建的其他方式

2.1 ExecutorService/Executors

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

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

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

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

2 线程的其他创建方法

public class TestRunnableV2 {
	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 悲观锁和乐观锁

悲观锁 ：像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态
悲观锁人为竞争总是会发生，因此每次对某子资源进行并发间操作时，都会持有一个独占的锁sysnchronzied，不管三七二十一，直接上了锁就操作资源。
乐观锁 ：还是像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态.
乐观锁认为竞争不总是会发生，因此它不需要持有锁，将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

3.2 两种常见锁

synchronize 互斥锁（悲观锁，有罪假设）
采用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 两种方式的区别和练习

所谓同步，可以理解为在执行完一个函数或方法之后，一直等待系统返回值或消息，这时程序是出于阻塞的，只有接收到返回的值或消息后才往下执行其它的命令。
异步，执行完函数或方法后，不必阻塞性地等待返回值或消息，只需要向系统委托一个异步过程，那么当系统接收到返回值或消息时，系统会自动触发委托的异步过程，从而完成一个完整的流程。
同步在一定程度上可以看做是单线程，这个线程请求一个方法后就待这个方法给他回复，否则他不往下执行(死心眼)。
同步就是一件事，一件事情一件事的做。
异步就是，做一件事情，不引响做其他事情。
例如：吃饭和说话，只能一件事一件事的来，因为只有一张嘴。但吃饭和听音乐是异步的，因为，听音乐并不引响我们吃饭。
对于Java程序员而言，我们会经常听到同步关键字synchronized，假如这个同步的监视对象是类的话，那么如果当一个对象访问类里面的同步方法的话，那么其它的对象如果想要继续访问类里面的这个同步方法的话，就会进入阻塞，只有等前一个对象执行完该同步方法后当前对象才能够继续执行该方法。这就是同步。相反，如果方法前没有同步关键字修饰的话，那么不同的对象可以在同一时间访问同一个方法，这就是异步。