12.线程同步机制

线程同步(多个线程操作同一个资源) synchronized

线程同步形成条件：队列 + 锁

关键字：synchronized

并发

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

• 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列

  等待前面线程使用完毕，下一个线程在使用

• 为了保证数据在方法中被访问时的正确性，在访问时加入了 锁机制synchronized

• 当一个线程获得对象的排他锁，独占资源，其他线程必须等待使用后释放锁即可，存在以下问题：

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起(性能减弱)
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和 调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

同步方法与同步块

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

• 同步块：synchronized (Obj){}

• synchronized 默认锁的是this

• 锁的对象就是变化的量，就是需要增删改的对象(哪个类的对象会发生变化，就锁哪个对象)

• synchronized方法控制对"对象"的访问，每个对象都有对应一把锁，

  每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，

  方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

• 缺陷：

  • 若将一个大的方法申明为synchronized将会影响效率
  • 方法里面需要修改的内容才需要锁，锁的太多，浪费资源

买票 synchronized 的处理

package com.syn;

// 不安全的买票
// 线程不安全。有负数
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();
    }
}

class BuyTicket implements Runnable{
    // 票
    private int ticketNums = 10;
    boolean flag = true; // 外部停止方式

    @Override
    public void run() {
        // 买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        // 判断是否有票
        if (ticketNums<0){
            flag = false;
            return;
        }
        // 模拟延时
        Thread.sleep(100);
        // 买票
        System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
    }
}

银行取钱 synchronized 的处理

package com.syn;

// 不安全的取钱
// 俩个人去银行取钱，账户
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
    @Override
    public void run() {
        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);

        }
    }
}

线程不安全的集合

package com.syn;

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

public class UnsafeList {
    public static void main(String[] args) {
        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());
    }
}

测试JUC安全类型的集合

package com.syn;

import java.util.concurrent.CopyOnWriteArrayList;

// 测试JUC安全类型的集合
public class TestJUC {
    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());
    }
}