七、线程同步

一、并发与并行

• 并发：同一时间段内，多个任务都在执行。CPU可以把执行时间分成若干份，每个线程执行一段时间后记录当前工作状态
• 并行：单位时间内多个任务同时执行

二、线程同步

注：

1. 锁的对象一定要是属性有增删改的对象！！！
2. 所谓线程同步并不是使线程同时执行，而是将线程排队！！！

1. 形成条件：队列 + 锁

为保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized， 当一个线程获得对象的排它锁独占资源时，其它线程必须等待。使用后释放锁即可。

会产生以下问题：

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

2. 同步方法

• private关键字可以保证数据只被方法访问，因此只需针对方法提出一套机制即可。即synchronized关键字

  public synchronized void method(int args) {}
  

• synchronized控制对对象的访问，每个对象对应一把锁

• 被synchronized修饰的方法只有当获得锁时才会执行，否则线程会阻塞

• 方法一旦执行就独占该锁，直到方法返回才会释放

• 若将一个较大的方法申明为synchronized将会影响效率

  • 只有对数据有修改操作的方法才需要锁，只读代码则不需要
  • 锁的太多则会浪费资源

3. 同步块

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

三、三大线程不安全案例

1. 不安全的抢票

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buy = new BuyTicket();
        new Thread(buy, "我").start();
        new Thread(buy, "欧皇").start();
        new Thread(buy, "黄牛党").start();
    }
}

class BuyTicket implements Runnable {
    private int ticketNum = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
        // 判断是否有票
        if (ticketNum <= 0) {
            flag = false;
            return;
        }
        // 模拟延时
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
    }
}

2. 不安全的取钱

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account("基金", 100);
        Drawing you = new Drawing(account, 50, "你");
        Drawing father = new Drawing(account, 100, "你的父亲");
        you.start();
        father.start();
    }
}

class Account {
    String name;
    int money;

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

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(this.getName() + "余额不足");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= drawingMoney;
        nowMoney += drawingMoney;

        System.out.println(account.name + "余额为：" + account.money);
        // 此处由于继承了Thread类，所以 this.getName() 效果等同于Thread.currentThread().getName()
        System.out.println(this.getName() + "现金有：" + nowMoney);
    }
}

3. 不安全的集合

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(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

四、修改案例

1. 修改后的抢票案例

将第24行代码修改为：

...
// 同步方法，锁的是this
private synchronized void buy() throws InterruptedException {
...

2. 修改后的取钱案例

由于同步方法默认锁的是当前对象，而该案例的实际操作数据的方法并不在数据发生变动的对象当中，因此需要用到同步块，在run()方法中进行修改：

@Override
public void run() {
    // 同步块，指定数据发生变动的对象
	synchronized (account) {
        // 判断余额是否充足，不足则退出方法
        if (account.money - drawingMoney < 0) {
            System.out.println(this.getName() + "余额不足");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= drawingMoney;
        nowMoney += drawingMoney;

        System.out.println(account.name + "余额为：" + account.money);
        // 此处由于继承了Thread类，所以 this.getName() 效果等同于Thread.currentThread().getName()
        System.out.println(this.getName() + "现金有：" + nowMoney);
    }
}

3. 修改后的集合案例

添加同步块，锁对象list即可：

for (int i = 0; i < 10000; i++) {
    new Thread(() -> {
        synchronized (list){
            list.add(Thread.currentThread().getName());
        }
    }).start();
}