三种线程不安全的场景及解决方案

线程不安全的解决方案实际上就是利用了队列+锁的机制
注：线程同步后势必会影响程序的性能

案例一：同一银行账户同时取钱
解决方案：同步代码块或者ReentrantLock可重入锁
synchronized (被锁对象) ：锁的对象就是数据修改的对象

//不安全的quqian
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "weddingFunding");
        Drawing you = new Drawing(account, 50, "y");
        Drawing gf = new Drawing(account, 100, "gf");
        you.start();
        gf.start();
    }
}

class Account{
    int money;
    String name;

    public Account() {
    }

    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 (被锁对象) ：锁的对象就是数据修改的对象
        synchronized (account){
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"余额不足！");
                return;
            }
            //sleep放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            account.money -= drawingMoney;
            nowMoney += drawingMoney;

            System.out.println(account.name+"余额为："+account.money);
            //Thread.currentThread().getName()=this.getName() 因为继承了Thread
            System.out.println(this.getName()+"手里的钱为"+nowMoney);
        }
    }
}

案例二：同时买票
解决方案：同步方法
synchronized 同步方法，默认锁的是this 即该对象

//不安全的买票
//线程安全队列+锁
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"乘客1").start();
        new Thread(buyTicket,"乘客2").start();
        new Thread(buyTicket,"乘客3").start();
    }
}

class BuyTicket implements Runnable{
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }

    private void stop(){
        this.flag = false;
    }
    //synchronized 同步方法，默认锁的是this 即该对象
    private synchronized void buy(){
        if (ticketNums<=0){
            flag = false;
            return;
        }

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

案例三：不安全的集合
解决方案：同步代码块(或者ReentrantLock可重入锁)或使用JUC的集合

1. 同步代码块

import java.util.ArrayList;
import java.util.List;

//线程不安全集合
//多个线程添加同一位置，会覆盖
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 30000; 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());
    }
}

2. JUC的集合

//测试JUC安全类型的集合

import java.util.concurrent.CopyOnWriteArrayList;

public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 30000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }
}

ReentrantLock可重入锁的使用

import java.util.concurrent.locks.ReentrantLock;

//测试lock锁
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;
    //定义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();//解锁
            }

        }
    }
}