【多线程】-- 10线程同步synchronized方法/块

news2025/1/19 3:02:47

多线程

6 线程同步

同步方法

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

synchronized方法和synchronized块

同步方法：

public synchronized void nethod(int args) {}

synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞。方法一旦执行，就会独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法声明为synchronized，将会影响效率。在方法中，需要修改的内容才需要锁（只读的内容不必同步修改），锁的太多自然会浪费资源。

同步块：

synchronized(Obj) {}

Obj称为同步监视器
- Obj可以是任何对象，但推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，即这个对象本身，或者是class(反射中会涉及)
同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

在上节所提到的三个不安全案例中，通过同步方法进行修改完善，可以发现代码运行结果发生了显著变化，并且是我们所期望看到的。

买票案例改：

package com.duo.synchronize;

//不安全案例1：买票
public class UnsafeCase1 {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station, "Hua").start();
        new Thread(station, "Ming").start();
        new Thread(station, "Hong").start();
    }
}

class BuyTicket implements Runnable {

    private int ticketNum = 10;
    boolean flag = true;

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

    //添加修饰词synchronized之后，此方法变为同步方法,锁的是this
    private synchronized void buy() {
        if (ticketNum <= 0) {
            flag = false;
            return;
        }

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

        System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
    }
}

运行结果：

在运行中，输出结果是间隔一秒挨个输出，且不再存在抢到同一张票的情况(即多个线程同时操作一个同一个对象)，也没有负数出现。

银行取钱案例改：

package com.duo.synchronize;

//不安全案例2：银行两人同时取钱
public class UnsafeCase2 {

    public static void main(String[] args) {
        Account account = new Account(1_000_000, "基金");

        Withdraw husband = new Withdraw(account, 500_000, "丈夫");
        Withdraw wife = new Withdraw(account, 1_000_000, "妻子");

        husband.start();
        wife.start();
    }
}

class Account {
    int balance;
    String name;

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

class Withdraw extends Thread {

    Account account;  //账户
    int transaction;  //交易金额
    int change;  //现在手中的零钱总金额

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

    //取钱
    @Override
    public void run() {  //若在此处添加synchronized修饰词并不会达到期望的效果，默认锁的是this

        synchronized (account) {
            if (account.balance - transaction < 0) {
                System.out.println(Thread.currentThread().getName() + "：账户余额不足，交易失败");
                return;
            }

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

            account.balance -= transaction;
            change += transaction;

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

            //Thread.currentThread().getName() == this.getName()
            System.out.println(this.getName() + "手中当前金额：" + change);
            System.out.println(account.name + "账户当前余额为：" + account.balance);
        }

    }
}

运行结果：

可以看到，通过synchronized可以控制对对象的访问。需要注意的是，此案例中不能直接在取钱的run()方法处添加synchronized修饰词，因为synchronized默认锁的是this，无法实现对账户account的锁定，故需将整个方法放入synchronized块中。

线程的不安全集合改：

package com.duo.synchronize;

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

//不安全案例3：线程不安全的集合
public class UnsafeCase3 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 5000; i++) {
            new Thread(() -> {
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }

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

        System.out.println(list.size());
    }
}

运行结果：

可以看到，在将list.add(Thread.currentThread().getName());放入synchronized块中后，集合列表输出的元素个数大小等于设定值5000.

【补充】JUC安全类型的集合测试

package com.duo.synchronize;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class JUCTest {

    public static void main(String[] args) {

        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();  //集合都加上泛型，规范

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

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

        System.out.println(list.size());
    }
}