线程同步：队列和锁，三大不安全案例；同步锁synchronized，死锁，lock锁-蒲公英云

线程同步

什么是线程同步

线程同步就是并发；多个线程操作同一个资源
线程同步实际就是一个等待机制，多个需要访问一个对象的线程进入这个对象的线程等待池形成队列，等待前一个线程使用完后在交由下一个线程使用。
形成条件：队列+锁

锁

当存在多个线程访问同一存储空间时，在访问的同时会导致冲突，导致数据出现错误，为保证数据的准确性，在访问对象时为每个对象加入锁，使得一个线程在访问这个存储空间时独占资源，其他线程等待锁的释放后才能访问这一线程。
使用锁存在的一些问题：
1. 一个线程的锁可能导致所有需要这把锁的线程就此挂起。
2. 在多线程中，锁的加入和锁的释放会引起性能问题
3. 如果一个优先级高的线程需要等待一个优先级低的线程的锁的释放会导致性能问题。

三大不安全案例

不安全的买票

由于每个线程都有自己的存储空间，所以在面对最后一张票时，所有线程都会将票拿到自己的存储空间中，所有导致最后的结果可能出现某个线程买了第-1张票的情况。
代码解释一下：

package com.XianCheng;
//不安全的买票
//使用多线程对同一资源进行操作没有添加同步锁。导致数据紊乱出现的不安全案例
public class Unsafeticket {
```
public static void main(String[] args) {
    //创建线程对象
    buy buy = new buy();
    new Thread(buy,"张一").start();
    new Thread(buy,"张二").start();
    new Thread(buy,"张三").start();
}
```
}
//创建线程，买票
class buy implements Runnable{

    //票
    private int ticket=10;
    //设置外部标志停止符
    Boolean flag=true;
    @Override
    public void run() {
        while (flag){
            try {
                Buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //创建买票方法
    public void Buy() throws InterruptedException {
        //判断是否有票
        if (ticket<0){
            flag=false;
            return;
        }
        //线程休眠，增加事件的可能性
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--);
    }
}

不安全的银行取钱

线程为同步，两个人都可在同一个账户中取钱，取钱的总金额可能大于账户余额，导致数据错误。

代码又来了，不懂看代码：

package com.XianCheng;
//模拟多线程取钱，导致的数据错误，从而出现的线程不安全
public class Unsafebank {

public static void main(String[] args) {
    //创建一个账户类的对象，并且给其赋值
    Account account = new Account("账户",100);
    //创建两个线程对象用于取钱
    getMoney getMoney = new getMoney(account,20);
    getMoney getMoney1 = new getMoney(account,90);
    new Thread(getMoney,"老公").start();
    new Thread(getMoney1,"老婆").start();
}

}

//创建一个账户类，用于保存账户的属性
class Account{

//账户名
String name;
//账户余额

int money;

public Account(String name, int money) {
    this.name = name;
    this.money = money;
}

}
//创建一个线程：取钱
class getMoney implements Runnable{

public getMoney(Account account, int num) {
    this.account = account;
    this.num = num;

// this.name = name;

}
//取钱的账户
Account account;
//取钱的数目
private int num;
//取钱人的名字
private String name;
//手里的前
private int nowMonwy;
@Override
public void run() {
    getWay();
}
//创建一个取钱方法
public void getWay(){
    //判断账户是否有钱
    if (account.money-num<0){
        System.out.println(Thread.currentThread().getName()+"账户钱不够");
        return;
    }
    //等待
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //有钱的情况
    //1.更改卡内余额
    account.money=account.money-num;
    //2.输出手里的前
    nowMonwy = nowMonwy+num;
    System.out.println(Thread.currentThread().getName()+"手里有"+nowMonwy);
    //输出余额
    System.out.println(account.name+"余额"+account.money);
}

}

不安全的数组集合

来咯来咯，直接来咯：

package com.XianCheng;

import java.util.ArrayList;

//不安全的线程集合
public class UnsafeThreadList {

public static void main(String[] args) {
    //新建一个list数组
    ArrayList<String> list = new ArrayList<String>();
    //向数组中添加数据
    for (int i = 0; i < 10000; i++) {
        //新建线程对象，将线程名加入数组中
        new Thread(()->{
           list.add(Thread.currentThread().getName());
        }).start();
    }
    //输出数组大小=>应该是10000
    System.out.println(list.size());
    //实际结果小于10000=>因为线程为同步，所有有可能多个线程将数据放到了数组中的同一位置，导致数组大小为达到期待值
}

}

同步锁

synchronized可以用于方法，锁定这个方法体本身，让这个方法体运行时资源只被一个线程使用，synchronized默认锁定this，即本身这个方法或类。
synchronized（锁的对象）{锁的方法体}，锁定的是这个对象，方法体内是对对象的一些操作。

juc安全类型集合

本质就是在不安全集合的基础上增加了synchronized锁，使得并发时，资源不会被多人占用，导致数据出错

更改的安全类型集合的代码：

package com;

import java.util.concurrent.CopyOnWriteArrayList;

//juc安全类型集合
public class safeLIst {

public static void main(String[] args) {
    //创建一个安全集合的对象
    CopyOnWriteArrayList<String> objects = new CopyOnWriteArrayList<String>();
    //添加数据
    for (int i = 0; i < 10000; i++) {
        objects.add(Thread.currentThread().getName());
    }
    System.out.println(objects.size());
}

}

死锁

死锁就是多个线程对于对方锁占有的资源有需求，但是都不将资源释放给对仿，程序就一直处于等待获取资源的状态，造成死锁。
给个例子，假设有两个资源：镜子，口红；同时有两个线程：男，女；此时男占有镜子不释放，同时想要获得口红，女占有口红不释放，同时想要获取镜子，这就会造成死锁。

代码说话：

package com.XianCheng;
//死锁现象的解释
public class DeadLocak {

public static void main(String[] args) {
    //创建线程对象
    Makeup man = new Makeup(0,"男");
    Makeup woman = new Makeup(1,"女");
    man.start();
    woman.start();
}

}
//创建资源：镜子
class mirror{

}
//创建资源：口红
class red{
}
//创建线程
class Makeup extends Thread{
    //实例化类，同时使用static保证资源只有一份
    static mirror m=new mirror();
    static red r=new red();
    //选择
    int choice;
    //使用对东西的对象
    String name;
    //构造器
    Makeup(int choice,String name){
        this.choice=choice;
        this.name=name;
    }
    @Override
    public void run() {
        makeup();
    }
    //化妆这个方法
    public void makeup(){
        //判断谁获取了哪样资源
        if (choice==0){
            synchronized (m){
    //谁拥有镜子这个锁
                System.out.println(Thread.currentThread().getName()+"拥有镜子这个锁");
                synchronized (r){
    //争夺口红这个锁
                    System.out.println(Thread.currentThread().getName()+"获得口红这个锁");
                }//将此处释放即可解除死锁
            }
        }
        else {
            synchronized (r){
    //谁拥有口红这个锁
                System.out.println(Thread.currentThread().getName()+"拥有口红这个锁");
                synchronized (m){
    //争夺镜子这个锁
                    System.out.println(Thread.currentThread().getName()+"获得镜子这个锁");
                }
            }
        }
    }
}

lock锁

package com.XianCheng;
import java.util.concurrent.locks.ReentrantLock;
//测试lock锁的使用，以买票为例
public class TestLock {
    public static void main(String[] args) {
        //创建线程对象
        Buy buy = new Buy();
        new Thread(buy,"1").start();
        new Thread(buy,"2").start();
        new Thread(buy,"3").start();
    }
}
//创建线程
class Buy implements Runnable{
    //定义票
    int num=10;
    //创建lock锁对象
    ReentrantLock re=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                re.lock();
                //判断是否有票
                if (num>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num--);
                }
                else {
                    break;
                }
            }finally {
                //解锁
                re.unlock();
            }
        }
    }
}