JavaThread 11 线程同步 → 同步方法及同步块

牟泉禹[Dark Cat]

已于 2022-07-08 05:54:29 修改

阅读量445

点赞数 1

分类专栏：学习笔记文章标签： java 多线程 thread

于 2021-07-17 18:27:56 首次发布

BY-牟泉禹/MuQuanyu

本文链接：https://blog.csdn.net/qq_52606908/article/details/118859992

版权

学习笔记专栏收录该内容

387 篇文章 11 订阅

订阅专栏

5.2 线程同步 → 同步方法及同步块

5.2.1 同步方法

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

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

意思就是，你如果想要保证数据的安全，那么就先要做最基本的安全措施， private 修饰一下！否则肯定不安全。。然后呢，利用锁来对方法进行一下针对！（锁是在用 synchronized 之后设定的同步监视器提供的！）

synchronized 同步方法会默认的把调用该方法的 this 对象设定为同步监视器！让 this 对象来提供锁。或者说被 synchronized 同步方法绑定的对象，都会给这个对象提供个同步锁。

synchronized 方法控制对 “对象” 的访问，每个对象对应一把锁，每个 synchronized() 方法都必须获得该对象的锁 （获取的方法很简单，让这个对象作为同步监视器就完事了），否则线程会进入阻塞状态，方法一旦被线程执行，线程就会独占该锁（这个锁一旦被线程独占，就被叫做 排它锁）。直到 synchronized 的代码块里正常执行完毕后才会释放该锁，后面被阻塞的线程才能获得再次操作该方法的权利，该对象也会继续提供给线程锁，然后再执行，然后再释放锁。

缺陷：若将一个大的方法申明为 synchronized 将会影响效率!(这是由于排它锁和释放锁上下文频繁切换导致的）

在这里插入图片描述
我们一般多线程去处理同一个事务的时候，只读部分不会加锁进行线程同步。只有修改部分的代码才会加锁进行线程同步。

package www.muquanyu.syn;

//不安全的买票 案例
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"黄牛").start();
        new Thread(station,"小明").start();
        new Thread(station,"老师").start();


    }

}

class BuyTicket implements Runnable {
    //票
    private int ticket = 10;

//哈哈，就加了个 修饰的关键字，synchronized 同步，会用到线程身上的的锁。
    @Override
    public synchronized void run() {
        //买票
        while(ticket > 0)
        {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->买到了第"+(ticket--)+"张票");
        }
    }
}

请看输出结果，你会非常的惊讶！（这么严重的问题居然这么轻松就解决了。）

黄牛–>买到了第10张票
黄牛–>买到了第9张票
黄牛–>买到了第8张票
黄牛–>买到了第7张票
黄牛–>买到了第6张票
黄牛–>买到了第5张票
黄牛–>买到了第4张票
黄牛–>买到了第3张票
黄牛–>买到了第2张票
黄牛–>买到了第1张票

但是我们说为什么只有黄牛这一个线程拿到资源了呢？这其实并不是表面看到的那样。其实是每次黄牛释放锁后，大家三个线程都同时再次抢夺这个资源。只不过恰好又被黄牛抢到了而已。

两人取钱就不可以这样方便的解决了！

package www.muquanyu.syn;

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

        Drawing you = new Drawing(account,50,"你");
        Drawing grilFriend = new Drawing(account,100,"你的女朋友");

        you.start();
        grilFriend.start();

    }
}

//账户（Java 版本的结构体）
class Account{
    int money;//余额
    String name;//卡名
    public Account( int money,String name)
    {
        this.money = money;
        this.name = name;
    }
    public Account(String name)
    {
        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;
    }

    @Override
    public synchronized void run() {
        //判断有没有钱
        if(account.money - drawingMoney < 0)
        {
            System.out.println(Thread.currentThread().getName()+"-->抱歉你的钱不够！");
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= drawingMoney;

        //你手里的钱
        nowMoney += drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱："+nowMoney);

    }
}

在这里插入图片描述
你会发现数据还是出现了错误，并发问题依然发生了，这是为什么呢？因为你锁的东西不对！根据我们的代码，你锁的是当前这个 class 创建的对象，分别是 you 和 grilFriend，相当于我们只实现了有顺序的进入银行，但是呢 ~ 你并未有顺序的取款呀。你应该锁的是那个账户，而不是两个线程对象 ~ ~

5.2.2 同步块

同步块：synchronized(Obj/* 待锁的对象 */){处理事务的代码}
Obj 称之为同步监视器

1.** Obj 可以是任何对象，但是推荐使用共享的那块儿资源作为同步监视器**

同步方法中无需指定同步监视器，这是因为同步方法的同步监视器默认指向的就是 this 它自己（对象）本身。或者是 class [反射中讲解]

同步监视器的执行过程

第一个线程访问，会获取同步监视器的锁，执行其中代码。

第二个线程访问，发现同步监视器被锁定，无法访问。进入阻塞状态。

第一个线程访问完毕，解除了同步监视器的锁，但是锁依然还在！可以供给第二个线程用。

第二个线程访问，发现同步监视器上面有释放锁，然后就把释放锁变成了排它锁，把自己和同步监视器锁上了，并且执行需要执行的代码。

两人取钱可以用同步块来解决

package www.muquanyu.syn;

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

        Drawing you = new Drawing(account,50,"你");
        Drawing grilFriend = new Drawing(account,100,"你的女朋友");

        you.start();
        grilFriend.start();

    }
}

//账户（Java 版本的结构体）
class Account{
    int money;//余额
    String name;//卡名
    public Account( int money,String name)
    {
        this.money = money;
        this.name = name;
    }
    public Account(String name)
    {
        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;
    }

    @Override
    public void run() {
        synchronized(account){
            //判断有没有钱
            if(account.money - drawingMoney < 0)
            {
                System.out.println(Thread.currentThread().getName()+"-->抱歉你的钱不够！");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingMoney;

            //你手里的钱
            nowMoney += drawingMoney;

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

在这里插入图片描述
正常情况，它会判断出你取 50 万，你女朋友取 100 万，那么当你取50 万的时候，你女朋友肯定就取不出来了。

那么如何让女朋友先取呢？

答：设置优先级，然后按照优先级的顺序写启动代码。

 grilFriend.setPriority(2);
        you.setPriority(1);
        
        grilFriend.start();
        you.start();

在这里插入图片描述

集合问题可以用同步块解决
错误解决：

package www.muquanyu.syn;

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

public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        synchronized (list){
            for(int i = 0;i < 10000;++i)
            {
                new Thread(()->{
                    list.add(Thread.currentThread().getName());
                }).start();
            }
            System.out.println(list.size());
        }
        
    }
}

在这里插入图片描述
原因是：你虽然把 list 对象设定为同步监视器了。但是只有主线程进入了队列。剩下的所有子线程都没有进入队列！这就导致了，你在做一个无用功 …

正确解决：

package www.muquanyu.syn;

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

public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();

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

    }
}

但是我们发现最后输出的还不是 10000，这是为什么呢？难道出错了吗？ 答案是：没出错！

原因是：主线程执行的比较快，子线程在刚要执行完的那一瞬间，主线程就把这个结果输出了。这也是多线程的魅力。如果多线程无法完成这种多个人同时工作的假象，那么也就没有任何意义了！！！

验证其正确性（如果我们说是因为主线程提前输出了，那么我们把输出放在所有的子线程里面不就完事了吗？这不是更准确吗？而且也验证了同步锁解决并发问题的正确性。）

package www.muquanyu.syn;

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

public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();

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

    }
}

在这里插入图片描述

小结

同步块比同步方法更加的灵活和好用！

锁是从哪来的？是设定同步监视器而来的。

如何让某个线程先被锁？设置优先级！

一定要注意是否你需要的线程会进来锁住自己呢？怎么万无一失的保证这一点？必须把同步块写在线程的事务（方法）里面！这样就可以完美的保证每个需要被锁的线程贱贱的 ~自动来找同步块获取到锁，把自己锁住 _嘿嘿(^▽)。

牟泉禹[Dark Cat]

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
JavaThread 11 线程同步 → 同步方法及同步块

5.2 线程同步 → 同步方法及同步块5.2.1 同步方法由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。同步方法：public synchronized void method(int args){}意思就是，你如果想要保证数据的安全，那么就先要做最基本的安全措施， private 修饰
复制链接

扫一扫

专栏目录