多线程学习笔记04线程同步
并发线程同步
三大不安全案例 同步方法
同步方法弊端 死锁Lock（锁）synchronized 与lock对比
多线程学习笔记04线程同步 并发同一个对象被多个线程同时操作，比如上万人同时抢100张票
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
并发实际上就是同一个对象被多个线程同时操作，这里强调三个点：
1、同一个对象（如果每个人操作自己的银行卡显然不会发生并发）
2、多个线程（如果这个银行卡只有你一个人用显然也不会发生问题）
3、同时操作（大家都在操作这个卡的时候，就会发生并发问题）。
并发三要素：同一个对象、多线程、同时。
一旦发生并发就会产生数据不准确的问题，之前的账户余额不对、12306的票出现了负数或者同一个位置被多个人买到，还有容器内的数据不对，这些都称为线程不安全。
保证线程安全可以通过“队列”和“锁”来完成。
线程同步线程同步实现的两个条件：①等待池形成队列；②资源上锁。
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized ，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。锁机制存在的问题：
一个线程持有锁会导致其他所有需要此锁的线程挂起；在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题；如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。 三大不安全案例
案例一，买票：
//线程不安全
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
//三个人买票
new Thread(station, "我").start();
new Thread(station, "你").start();
new Thread(station, "黄牛党").start();
}
}
class BuyTicket implements Runnable {
//票
private int ticketNums = 10;
boolean flag = true;//外部停止方式
@Override
public void run() {
//买票
while (flag) {
buy();
}
}
private void buy() {
//判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
//模拟延时
try {
Thread.sleep(80);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
}
}
运行结果：
存在0和-1，线程不安全！
0和-1是怎么来的？
每个线程都在自己的工作内存交互，内存控制不当会造成数据不一致
当余票数显示为1时，我、你、黄牛党都看到余数为1，都进行买票操作，当其中一个人成功拿到1时，余票为0，0被第二个人拿到后，余票为-1且被第三个人拿到，这就是原因所在。由此可见，如果不让三者排队，则线程会变得非常不安全。
案例二，银行取钱：
//不安全的取钱
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "你");//你要取50万
Drawing girlfriend = new Drawing(account, 100, "girlfriend");//你你女朋友要全部取走
//你们两个都要取钱
you.start();
girlfriend.start();
}
}
//账户
class Account {
int money;//余额
String name;//卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行，模拟取款
class Drawing extends Thread {
Account account;//账户
//取了多少钱
int drawingMoney;
//手中现有多少钱
int nowMoney;
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
@Override
public void run() {
//判断有没有钱
if (account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + "钱不够，无法取钱");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额=余额-你取的钱
account.money = account.money - drawingMoney;
//手中的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为：" + account.money);
//这里this.getName()等价于Thread.currentThread().getName()
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
运行结果：
原本卡内只有100万，两人都成功取钱，卡中余额为-50，线程不安全！
案例三，不安全的集合：
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合，ArrayList就是一个
public class UnsafeList {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start();
}
System.out.println(list.size());
}
}
同步方法不安全的原因是有两个线程在同一瞬间，将两个数组添加到同一个位置，从而产生了数据覆盖。
由于我们可以通过private关键字来保证数据对象只能被方法访问（get、set方法），所以我们只需要针对方法提出一套机制，这套机制就是synchronized 关键字，它包括两种用法：synchronized方法和synchronized块
同步方法： public synchronized void method(int args){}synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺陷：若将一个大的方法申明为synchronized 将会影响效率
同步方法弊端
方法里面需要修改的内容才需要锁，锁的太多，浪费资源
将购票案例优化：
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
//三个人买票
new Thread(station, "我").start();
new Thread(station, "你").start();
new Thread(station, "黄牛党").start();
}
}
class BuyTicket implements Runnable {
//票
private int ticketNums = 10;
boolean flag = true;//外部停止方式
@Override
public void run() {
//买票
while (flag) {
buy();
}
}
//synchronized同步方法，锁的是this
private synchronized void buy() {
//判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
//模拟延时
try {
Thread.sleep(80);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
}
}
运行结果：
同步块：synchronized (Obj ){ }Obj称之为同步监视器
Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this ，就是这个对象本身，或者是 class[反射中讲解]同步监视器的执行过程
1、第一个线程访问，锁定同步监视器，执行其中代码；
2、第二个线程访问，发现同步监视器被锁定，无法访问；
3、第一个线程访问完毕，解锁同步监视器；
4、第二个线程访问，发现同步监视器没有锁，然后锁定并访问
优化取钱案例：
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "你");//你要取50万
Drawing girlfriend = new Drawing(account, 100, "girlfriend");//你你女朋友要全部取走
//你们两个都要取钱
you.start();
girlfriend.start();
}
}
//账户
class Account {
int money;//余额
String name;//卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行，模拟取款
class Drawing extends Thread {
Account account;//账户
//取了多少钱
int drawingMoney;
//手中现有多少钱
int nowMoney;
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
@Override
public void run() {
//锁的对象就是变化的量，需要增删改的对象
synchronized (account) {
//判断有没有钱
if (account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + "钱不够，无法取钱");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额=余额-你取的钱
account.money = account.money - drawingMoney;
//手中的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为：" + account.money);
//这里this.getName()等价于Thread.currentThread().getName()
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
}
运行结果：
至于不安全的集合：
public class UnsafeList {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
案例 化妆：
化妆需要两个资源，口红和镜子
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0, "灰姑娘");
Makeup g2 = new Makeup(1, "白雪公主");
g1.start();
g2.start();
}
}
//口红
class Lipstick {
}
//镜子
class Mirror {
}
class Makeup extends Thread {
//需要的资源只有一份，用static来保证
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;//选择
String girlName;//使用化妆品的人
public Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆方法,互相持有对方的锁，需要拿到对方的资源
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {//获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
synchronized (mirror) {//一秒钟后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
}
} else {
synchronized (mirror) {//获得镜子的锁
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(2000);
synchronized (lipstick) {//一秒钟后想获得镜子
System.out.println(this.girlName + "获得口红的锁");
}
}
}
}
}
运行结果：
灰姑娘获得口红，下一步她想获得镜子，而白雪公主获得了镜子，下一步她想获得口红，所以程序僵持在这里无法继续。
解决办法：
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {//获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
}
synchronized (mirror) {//一秒钟后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
} else {
synchronized (mirror) {//获得镜子的锁
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(2000);
}
synchronized (lipstick) {//一秒钟后想获得镜子
System.out.println(this.girlName + "获得口红的锁");
}
}
}
不要抱着对方的锁
运行结果：
Lock（锁）小结
产生死锁的四个必要条件：1、互斥条件：一个资源每次只能被一个进程使用。2、请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。3、不剥夺条件:进程已获得的资源，在未使用完之前，不能强行剥夺。4、循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
以上四个必要条件，只要想办法破其中的任意一个或多个条件就可以避免死锁发生
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
案例，多个线程操作同一个对象：
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
//三个线程同时操作一个对象
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable{
int ticketNums = 10;
@Override
public void run() {
while (true){
if(ticketNums>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}else {
break;
}
}
}
}
运行结果：
线程不安全！
解决办法：
class TestLock2 implements Runnable {
int ticketNums = 10;
//定义lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();//加锁
if (ticketNums > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
} else {
break;
}
} finally {
//解锁
lock.unlock();
}
}
}
}
运行结果：
解决。
代码结构：
class A{
private final ReentrantLock lock = new ReentrantLock();
public void m() {
lock.lock();
try {
//保证线程安全的代码
} finally {
lock.unlock();
//如果同步代码有异常，要将unlock()写入finally语句块
}
}
}
synchronized 与lock对比
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放Lock只有代码块锁，synchronized有代码块锁和方法锁使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)优先使用顺序：
Lock > 同步代码块（已经进入了方法体，分配了相应资源) > 同步方法（在方法体之外)
