同步方法及同步块

如果我们意识不到思维方式中的弱点，我们永远无法突破当前困境

上篇博客三大线程不安全例子中给出了不安全的示例，那如何才是安全的呢？

同步方法

synchronized关键字，同步，可以放在方法前

public synchronized void method(int args){}

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

同步块

也可以写成 synchronized方法块

synchronized(Obj){}

Obj 称为同步监视器

Obj可以是任意对象，推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个而对象本身，或者是class(反射中讲解)

同步监视器的执行过程

第一个线程访问，锁定同步监视器，执行其中代码

第二个线程访问，发现同步监视器被锁定，无法访问

第一个线程访问完毕，解锁同步监视器

第二个线程访问，发现同步监视器没有多，锁定同步监视器，执行其中代码

上个博客中的三个方法修正

不安全买票:采用同步方法

package com.example.multi_thread;

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket(10);
        Thread t1 = new Thread(ticket, "我");
        Thread t2 = new Thread(ticket, "你");
        Thread t3 = new Thread(ticket, "黄牛");
        t1.start();
        t2.start();
        t3.start();

    }
}

class Ticket implements Runnable {

    private int num;

    boolean flag = true;

    public Ticket(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (flag) {

            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

    private synchronized void buy() throws InterruptedException {
        if (num <= 0) {
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + "拿到" + num--);
    }


}

输出: 感觉改成同步方法之后，一个线程会获得连续获得执行机会，读者可以自行换成100试下

我拿到10
我拿到9
我拿到8
我拿到7
我拿到6
我拿到5
我拿到4
我拿到3
我拿到2
我拿到1

取钱：

package com.example.multi_thread;

import lombok.SneakyThrows;

public class DrawingMoney {
    public static void main(String[] args) {
        Account account = new Account(100, "my");

        Drawing drawing1 = new Drawing(account, 50, "我");
        Drawing drawing2 = new Drawing(account, 100, "boyFriend");

        drawing1.start();
        drawing2.start();
    }
}

// 账户
class Account {
    int balance; // 余额
    String name; // 账户名称

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

class Drawing extends Thread {

    private Account account;
    private int drawingMoney;
    private int nowMoney;//

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @SneakyThrows
    @Override
    public void run() {
        synchronized (account) {
            if (account.balance - drawingMoney < 0) {
                System.out.println(currentThread().getName() + "余额不足");
                return;
            }
            // 模拟网络延时
            Thread.sleep(3000);
            account.balance -= drawingMoney;
            nowMoney += drawingMoney;
            System.out.println(account.name + "账户余额" + account.balance);
            System.out.println(currentThread().getName() + "手里的钱" + nowMoney);
        }


    }


}

输出：

my账户余额50
我手里的钱50
boyFriend余额不足

ArrayList

package com.example.multi_thread;

import java.util.ArrayList;

public class TestArrayList {
    public static void main(String[] args) {
        ArrayList<Object> objects = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                synchronized (objects) {
                    objects.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(objects.size());
    }
}

输出

10000