同步方法跟同步方法块 synchronized

• synchronized方法控制对象的访问，每个对象对应一把锁，每个synchronized方法都必须获得改方法的对象的锁才能执行,否则线程会阻塞，方法一旦执行，就独占这把锁，知道方法结束才释放锁，后面被阻塞的线程才能获得这个锁被执行
• synchronized关键字可以用在方法上标识锁住this对象
• synchronized（Obj）方法块用在方法内 Obj是被锁的对象

 

代码示例1 模拟买票

package 多线程练习.锁学习;

public class 不安全线程买票实例 {
    public static void main(String[] args) {
        BuyTicket bt = new BuyTicket();
        new Thread(bt, "小明").start();
        new Thread(bt, "王老师").start();
        new Thread(bt, "黄牛党").start();
    }
}


/*
   模拟一个买票的线程接口实现类
 */
class BuyTicket implements Runnable {

    private int ticket = 10;
    private Boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            buy();
        }
    }

    /*
       买票方法
     */
    public synchronized void buy() {
        // 票卖完了
        if (ticket <= 0) {
            flag = false;
            return;
        }

        // 模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //模拟买票
        System.out.println(Thread.currentThread().getName() + " 买到了第 " + ticket-- + " 张表");
    }
}

输出结果

 

 

代码示例2 模拟银行取钱

package 多线程练习.锁学习;

import java.math.BigDecimal;

/*
   模拟两个人同时取钱的情况
 */
public class SafeAccount {
    public static void main(String[] args) {
        Bank bank = new Bank("12345", new BigDecimal("100"));
        WithDrawMoney xiaoming = new WithDrawMoney(bank, new BigDecimal("50"), "小明");
        WithDrawMoney xiaomingxf = new WithDrawMoney(bank, new BigDecimal("100"), "小明媳妇");
        xiaoming.start();
        xiaomingxf.start();

    }
}


/*
   银行类
 */
class Bank {
    String cardNumer;    // 卡号
    BigDecimal balance;  // 余额  小tip:Java中用BigDecimal 来表示金钱类型

    public Bank(String cardNumer, BigDecimal balance) {
        this.cardNumer = cardNumer;
        this.balance = balance;
    }

}

class WithDrawMoney extends Thread {
    //  模拟正式环境全部私有
    Bank bank;
    BigDecimal nowMoney = new BigDecimal("0");   // 手里的钱
    BigDecimal drawMoney;  // 取走的钱

    // 构造方法
    public WithDrawMoney(Bank bank, BigDecimal drawMoney, String name) {
        super(name);  // 调用父类的只能用在第一行
        this.bank = bank;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {

        /*
        synchronized 用在方法上面 则不需要在方法内加synchronized代码块  用在方法指定的是锁this对象 反射类。
        synchronized 应当需要锁住的对象
         */
        synchronized (bank) {
            if (bank.balance.subtract(drawMoney).compareTo(BigDecimal.ZERO) == -1) {
                System.out.println(this.getName() + " 钱不够了，取钱失败");  // 线程类中this.getName() ==  Thread.currentThread.getName()
                return;
            }

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

            nowMoney = nowMoney.add(drawMoney);                       // 手里的钱
            bank.balance = (bank.balance.subtract(drawMoney));        // 卡上余额 subtract 减法  add 加法
            System.out.println(this.getName() + " 手里有 " + nowMoney + "钱");
            System.out.println("卡上余额：" + bank.balance);
        }

    }


}

 

输出结果

 

 

 

代码示例3 容器

package 多线程练习.锁学习;

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

/*
  synchronized(Obj) 此处的 是锁住list对象
  Obj又称同步监视器
 */
public class SafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

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

        // Sleep就是为了扩大事情的发展面
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("数量为：" + list.size());

    }
}

 

输出结果