多线程基础-05

6.线程同步（重点）

线程同步发生在什么时候呢？–多个线程操作同一个资源。

并发：同一个对象被多个线程操作

• 现实生活中，我们会遇到 "同一个资源，多人都想使用"的问题【并发问题】，比如：食堂排队打饭，每个人都想吃饭，最天然的解决办法就是：排队，一个一个来。
• 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。
• 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个**对象的等待池**形成排队，等待前面线程使用完毕，下一个线程再使用。

队列和锁

• 队列：相当于排队
• 锁：在形成排队的情况下，进行锁住最前的线程先执行，且不受其他线程的影响！【例子：排队上厕所】

线程同步安全性的形成条件：队列+锁

• 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题，为了保证数据在方法中被访问时的正确性，在访问时加入**锁机制synchronized,当一个线程获得对象的排他锁**，独占资源，其他线程必须等待，使用后释放锁即可，但存在以下问题：
  • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
  • 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题【必然存在】；
  • 如果一个优先级高的线程去等待一个优先级低的线程，释放锁会导致优先级倒置，从而引发性能问题；

三大不安全案例：

案例1：线程不安全的买车票

// 案例一：线程不安全的购买车票
public class UnSafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"王五").start();
        new Thread(buyTicket,"赵六").start();
        new Thread(buyTicket,"田七").start();
        new Thread(buyTicket,"朱八").start();
    }
}


class BuyTicket implements Runnable{

    // 定义10张票
    private int nums = 10;
    // 标志位
    private boolean flag = true;

    @Override
    public void run() {

        // 买票
        while (flag) {
            try {
                Buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 买票方法
    public void Buy() throws InterruptedException {

        // 判断是否有票
        if (nums <= 0) {
            flag = false;//修改标志位
            return;
        }

        // 添加延时：目的是-增加事件发生的可能性
        Thread.sleep(100);

        // 买票
        System.out.println(Thread.currentThread().getName()+"--->拿到第 "+ (nums--) +" 票");

    }

}

执行结果1：

赵六--->拿到第 5 票
朱八--->拿到第 9 票
王五--->拿到第 8 票
张三--->拿到第 7 票
李四--->拿到第 10 票
田七--->拿到第 6 票
王五--->拿到第 3 票
赵六--->拿到第 4 票
张三--->拿到第 1 票
朱八--->拿到第 2 票
田七--->拿到第 2 票
李四--->拿到第 2 票
------------------------
张三、朱八、田七、李四 这四个人同时拿到了第二张票！线程不安全！

执行结果2：

李四--->拿到第 7 票
朱八--->拿到第 10 票
赵六--->拿到第 9 票
田七--->拿到第 10 票
王五--->拿到第 6 票
张三--->拿到第 8 票
赵六--->拿到第 4 票
田七--->拿到第 5 票
李四--->拿到第 2 票
张三--->拿到第 5 票
王五--->拿到第 5 票
朱八--->拿到第 3 票
王五--->拿到第 1 票
赵六--->拿到第 1 票
张三--->拿到第 1 票
田七--->拿到第 -1 票
朱八--->拿到第 -2 票
李四--->拿到第 0 票
---------------------
田七、朱八拿到负数！线程不安全！

造成的原因是：没有进行排队！！！

案例2：线程不安全的取钱

// 线程不安全的取钱
// 两个人去银行取钱,同一个账户
public class UnSafeBank {

    public static void main(String[] args) {
        // 账户
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,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;
    }


    // 取钱
    // 重写run()方法
    @Override
    public void run() {
        // 判断有没有钱
        if (account.money - drawingMoney < 0) {
            System.out.println(Thread.currentThread().getName() + "男士/女士，余额不足！");
            return;
        }

        // sleep可以增加问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 卡内余额 = 余额 - 取的额度
        account.money = account.money - drawingMoney;
        // 你手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name + "余额为："+account.money);
        //Thread.currentThread().getName() 等价于 this.getName()
        System.out.println(this.getName() + "手里的钱："+nowMoney);

    }


}

执行结果：

结婚基金余额为：50
你手里的钱：50
结婚基金余额为：-50
girlFriend手里的钱：100

案例3：线程不安全的集合

// 线程不安全的集合：ArrayList
public class UnSafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() ->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        // 放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

        /**
         * 不安全的原因是：
         *  是因为在某一时刻两个线程同一瞬间操作了同一个位置【也就是把两个数据添加到了同一位置】，导致覆盖，从而元素会变少！
         */
    }
}

同步方法(synchronized方法)：解决线程不安全

synchronized关键字实现原理：队列+锁

• 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块

  同步方法：public synchronized void method(int args){}

• synchronized方法控制对 “对象” 的访问，每个对象对应一把锁，每个 synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才能释放锁，后面被阻塞的线程才能获得这个锁，继续执行

  缺陷：若将一个大的方法申明为synchronized 将会影响效率

  缺陷原因分析：

  • 同步方法的弊端

    

同步块(synchronized块)

• 同步块：synchronized(obj){}
• obj称之为 同步监视器
  • obj 可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是 class [反射中讲解的]
  • obj在代码中其实就指代发生增删改的对象！
• 同步监视器的执行过程：
  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

案例1：修改为线程安全

public class UnSafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"王五").start();
        new Thread(buyTicket,"赵六").start();
        new Thread(buyTicket,"田七").start();
        new Thread(buyTicket,"朱八").start();
    }
}


class BuyTicket implements Runnable{

    // 定义10张票
    private int nums = 10;
    // 标志位
    private boolean flag = true;

    @Override
    public void run() {

        // 买票
        while (flag) {
            try {
                Buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 给买票方法添加synchronized关键字,变成synchronized同步方法,锁的是this
    public synchronized void Buy() throws InterruptedException {

        // 判断是否有票
        if (nums <= 0) {
            flag = false;//修改标志位
            return;
        }

        // 添加延时：目的是-增加事件发生的可能性
        Thread.sleep(100);

        // 买票
        System.out.println(Thread.currentThread().getName()+"--->拿到第 "+ (nums--) +" 票");

    }

}

执行结果：

张三--->拿到第 10 票
张三--->拿到第 9 票
张三--->拿到第 8 票
张三--->拿到第 7 票
张三--->拿到第 6 票
张三--->拿到第 5 票
张三--->拿到第 4 票
张三--->拿到第 3 票
张三--->拿到第 2 票
张三--->拿到第 1 票

总结

添加synchronized关键字修饰方法，相当于将没有排队的线程进行了排队！

案例2：修改为线程安全

public class UnSafeBank {

    public static void main(String[] args) {
        // 账户
        Account account = new Account(1000,"结婚基金");

        Drawing you = new Drawing(account,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;
    }


    // 取钱
    // synchronized 默认锁的是 this[指代类本身] 此处this 指代Drawing类
    // 将run()方法改成synchronized修饰的方法,此时的this是bank,但是我们操作的并不是银行,而是账户
    // 总结：要对实际发生变化的地方添加同步,才有效果
    @Override
//    public synchronized void run() {
    public void run() {

        // 应该使用synchronized(obj){}:方法块，其中obj是共享资源
        // 锁的对象就是变化的量！也就是需要增删改的对象！
        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 = account.money - drawingMoney;
            // 你手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name + "余额为："+account.money);
            //Thread.currentThread().getName() 等价于 this.getName()
            System.out.println(this.getName() + "手里的钱："+nowMoney);
        }
    }
}

执行结果：

结婚基金余额为：950
你手里的钱：50
结婚基金余额为：850
girlFriend手里的钱：100

案例3：修改为线程安全

public class UnSafeList {
    public static void main(String[] args) {
        // 在这里变化的量是ist,所以锁list即可
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() ->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        // 放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

执行结果：

10000

补充：java并发包JUC包[java.util.concurrent]下的类

// 测试JUC安全类型的集合
public class TestJUCList {

    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }

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

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