Java线程同步机制&Synchronized

Bro_cat

于 2024-09-04 18:19:56 发布

阅读量349

点赞数 9

分类专栏： Java 文章标签： java jvm 开发语言线程同步机制

本文链接：https://blog.csdn.net/Broken_x/article/details/141900079

版权

Java 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

同步机制的基本概念

想象一下，你和几个朋友一起去抢购限量版的商品。如果大家同时抢购，可能会导致混乱，比如两个人同时拿到最后一件商品，或者有人多拿了。为了避免这种情况，你们可以约定一个规则：每次只有一个人可以拿商品，其他人必须等待。这就是同步机制的基本思想——确保在同一时间只有一个线程可以访问共享资源。

Synchronized关键字的作用

synchronized关键字就像是给共享资源上了一把锁。当一个线程访问这个资源时，它会锁住这个资源，其他线程必须等待锁被释放后才能访问。

同步方法

同步方法是将整个方法都锁住。当一个线程调用同步方法时，它会获得这个方法所属对象的锁，其他线程必须等待锁被释放。

示例1：售票问题

public class TicketSystem {
    private int tickets = 10; // 总票数

    // 同步方法：售票
    public synchronized void sellTicket() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票");
            tickets--;
        } else {
            System.out.println(Thread.currentThread().getName() + " 票已售完");
        }
    }

    public static void main(String[] args) {
        TicketSystem ticketSystem = new TicketSystem();

        // 创建多个线程模拟多个窗口售票
        for (int i = 1; i <= 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (ticketSystem.tickets > 0) {
                        ticketSystem.sellTicket();
                        try {
                            Thread.sleep(100); // 模拟售票时间
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "窗口" + i);
            thread.start();
        }
    }
}

示例2：银行账户存款/取款问题

public class BankAccount {
    private double balance = 1000; // 初始余额

    // 同步方法：存款
    public synchronized void deposit(double amount) {
        balance += amount;
        System.out.println(Thread.currentThread().getName() + " 存款 " + amount + " 元，当前余额：" + balance);
    }

    // 同步方法：取款
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println(Thread.currentThread().getName() + " 取款 " + amount + " 元，当前余额：" + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + " 余额不足，无法取款 " + amount + " 元");
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();

        // 创建多个线程模拟多个操作
        for (int i = 1; i <= 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    account.deposit(100);
                    try {
                        Thread.sleep(100); // 模拟操作时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    account.withdraw(50);
                }
            }, "操作" + i);
            thread.start();
        }
    }
}

Thread thread = new Thread(new Runnable() { ... }); 这行代码的意思是创建一个新的线程，并为其提供一个实现了 Runnable 接口的匿名内部类实例。具体来说，这行代码可以分解为以下几个部分：

创建线程对象：new Thread() 创建了一个新的 Thread 对象。
传递 Runnable 实例：new Runnable() { ... } 创建了一个匿名内部类，该类实现了 Runnable 接口，并重写了 run() 方法。这个匿名内部类的实例被传递给 Thread 的构造函数。
启动线程：thread.start() 方法将启动新线程，新线程将执行 Runnable 实例中的 run() 方法。

同步代码块

同步代码块是将方法中的一部分代码锁住。你可以指定一个对象作为锁，只有获得这个对象锁的线程才能执行同步代码块。

示例1：售票问题

public class TicketSystem {
    private int tickets = 10; // 总票数
    private final Object lock = new Object(); // 锁对象

    // 同步代码块：售票
    public void sellTicket() {
        synchronized (lock) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票");
                tickets--;
            } else {
                System.out.println(Thread.currentThread().getName() + " 票已售完");
            }
        }
    }

    public static void main(String[] args) {
        TicketSystem ticketSystem = new TicketSystem();

        // 创建多个线程模拟多个窗口售票
        for (int i = 1; i <= 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (ticketSystem.tickets > 0) {
                        ticketSystem.sellTicket();
                        try {
                            Thread.sleep(100); // 模拟售票时间
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "窗口" + i);
            thread.start();
        }
    }
}

示例2：银行账户存款/取款问题

public class BankAccount {
    private double balance = 1000; // 初始余额
    private final Object lock = new Object(); // 锁对象

    // 同步代码块：存款
    public void deposit(double amount) {
        synchronized (lock) {
            balance += amount;
            System.out.println(Thread.currentThread().getName() + " 存款 " + amount + " 元，当前余额：" + balance);
        }
    }

    // 同步代码块：取款
    public void withdraw(double amount) {
        synchronized (lock) {
            if (balance >= amount) {
                balance -= amount;
                System.out.println(Thread.currentThread().getName() + " 取款 " + amount + " 元，当前余额：" + balance);
            } else {
                System.out.println(Thread.currentThread().getName() + " 余额不足，无法取款 " + amount + " 元");
            }
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();

        // 创建多个线程模拟多个操作
        for (int i = 1; i <= 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    account.deposit(100);
                    try {
                        Thread.sleep(100); // 模拟操作时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    account.withdraw(50);
                }
            }, "操作" + i);
            thread.start();
        }
    }
}

同步方法和同步代码块的作用

同步方法：

作用：确保在同一时间只有一个线程可以执行该方法。
适用场景：当整个方法都需要同步时，使用同步方法比较方便。

同步代码块：

作用：确保在同一时间只有一个线程可以执行代码块中的代码。
适用场景：当只需要部分代码需要同步时，使用同步代码块更加灵活。

在Java中，Object类是所有类的根类，即所有类都直接或间接继承自Object类。Object类提供了一些基本的方法，如equals()、hashCode()、toString()等，这些方法在所有对象中都可以使用。

当你需要一个锁对象来进行同步操作时，你可以使用任何对象作为锁对象，但通常推荐使用new Object()来创建一个专门用于同步的锁对象。这样做的原因如下：

明确用途：使用new Object()创建的锁对象专门用于同步，不会与其他用途的对象混淆，确保同步操作的清晰性和安全性。
避免意外共享：如果使用某个已有对象作为锁对象，可能会导致意外的共享和竞争条件。使用new Object()创建的锁对象是私有的，不会被其他代码访问或共享。
简化管理：专门创建的锁对象更容易管理和维护，不会与其他对象的功能和生命周期混淆。

为什么推荐Object类？

通用性：Object类是所有类的根类，即所有类都直接或间接继承自Object类。因此，任何对象都可以作为锁对象使用。使用Object类作为锁对象具有通用性，适用于所有情况。
简洁性：Object类没有任何特殊的行为或状态，仅仅是一个空对象。使用Object类作为锁对象可以避免锁对象本身带有额外状态或行为，从而减少潜在的复杂性和错误。
安全性：使用Object类作为锁对象可以确保锁对象的唯一性和私有性。通过private final Object lock = new Object();的方式创建锁对象，可以防止外部代码误用或恶意操作锁对象，从而提高并发操作的安全性。

虽然其他类也可以作为锁对象使用，但使用Object类作为锁对象有以下优势：

避免意外共享：如果使用某个已有对象作为锁对象，可能会导致意外的共享和竞争条件。使用new Object()创建的锁对象是私有的，不会被其他代码访问或共享。
简化管理：专门创建的锁对象更容易管理和维护，不会与其他对象的功能和生命周期混淆。

因此，private final Object lock = new Object();这行代码的意思是：

声明一个私有的（private）、不可变的（final）对象（Object），并将其命名为lock。
使用new Object()创建一个Object类的实例，并将其赋值给lock变量。

通过这两种方式，可以有效地避免多个线程同时访问共享资源导致的冲突和不一致问题。

Bro_cat

关注

9
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java线程同步机制&Synchronized

为了避免这种情况，你们可以约定一个规则：每次只有一个人可以拿商品，其他人必须等待。当一个线程访问这个资源时，它会锁住这个资源，其他线程必须等待锁被释放后才能访问。当一个线程调用同步方法时，它会获得这个方法所属对象的锁，其他线程必须等待锁被释放。你可以指定一个对象作为锁，只有获得这个对象锁的线程才能执行同步代码块。当你需要一个锁对象来进行同步操作时，你可以使用任何对象作为锁对象，但通常推荐使用。这行代码的意思是创建一个新的线程，并为其提供一个实现了。类是所有类的根类，即所有类都直接或间接继承自。
复制链接

扫一扫

专栏目录