java 的 synchronized 同步方法使用场景举例解读

小灰灰 2021-01-19 17:12 722阅读 0赞

# 前言： #

线程同步是指多个线程同时访问某一个共享资源，保证在同一时间只能有一个线程访问该资源。

java 一般用 synchronized 关键字来做线程同步，简单实用，下面直接给个例子说明一下。

## 一、 举个买票的例子 ##

一般大家也会用这个来举例，很常见也便于理解。

1. 首先创建一个Ticket 类用于表述车票，如下：

/**
     * 车票类
     */
    public class Ticket {
        private Integer ticketNum;
    
        Ticket(int ticketNum) {
            this.ticketNum = ticketNum;
        }
    
         // synchronized 这里先注销这个同步关键字
         void buyTicket(int amount) {
    
            System.out.println("当前可售票数： " + ticketNum);
            if (ticketNum < amount) {
                System.out.println("目前剩余票数" + ticketNum + ", 购票" + amount + ", 可售票数不足");
            } else {
                ticketNum = ticketNum - amount;
                System.out.println("购票" + amount + ", 剩余票数" + ticketNum);
                if (ticketNum <= 0) {
                    System.out.println("票售罄");
                }
            }
    
        }
    }

2. 创建一个客户端类 BuyTicketClient 用于提供买票服务

/**
     * 购票服务端
     */
    
    public class BuyTicketClient implements Runnable {
    
        Ticket ticket;
        int amount;
    
        BuyTicketClient(Ticket ticket, int amount) {
            this.ticket = ticket;
            this.amount = amount;
    
        }
    
        public void run() {
            ticket.buyTicket(amount);
        }
    }

3. 模拟多人购票

/**
     * 模拟多人购票
     */
    
    public class Buy {
        public static void main(String[] args) {
            Ticket ticket = new Ticket(5);
            BuyTicketClient buyTicketClient_1 = new BuyTicketClient(ticket, 2);
            BuyTicketClient buyTicketClient_2 = new BuyTicketClient(ticket, 1);
            BuyTicketClient buyTicketClient_3 = new BuyTicketClient(ticket, 3);
    
            Thread thread_3 = new Thread(buyTicketClient_3);
            Thread thread_2 = new Thread(buyTicketClient_2);
            Thread thread_1 = new Thread(buyTicketClient_1);
    
            thread_3.start();
            thread_2.start();
            thread_1.start();
        }
    }

运行看一下结果（每次运行结果可能都不同）：

当前可售票数： 5
    当前可售票数： 5
    当前可售票数： 2
    目前剩余票数0, 购票1, 可售票数不足
    购票2, 剩余票数0
    购票3, 剩余票数2
    票售罄
    票售罄

会发现输出结果完全对不上，主要原因是多线程执行顺序不可控，票数量（ticketNum字段）修改是混乱的。

4. 加 synchronized 字段做同步

步骤1代码中buyTicket方法加 synchronized字段，如下

/**
     * 车票类
     */
    public class Ticket {
        private Integer ticketNum;
    
        Ticket(int ticketNum) {
            this.ticketNum = ticketNum;
        }
    
         synchronized void buyTicket(int amount) {
    
            System.out.println("当前可售票数： " + ticketNum);
            if (ticketNum < amount) {
                System.out.println("目前剩余票数" + ticketNum + ", 购票" + amount + ", 可售票数不足");
            } else {
                ticketNum = ticketNum - amount;
                System.out.println("购票" + amount + ", 剩余票数" + ticketNum);
                if (ticketNum <= 0) {
                    System.out.println("票售罄");
                }
            }
    
        }
    }

再次运行步骤3的代码，结果如下（每次运行结果可能不同）：

当前可售票数： 5
    购票3, 剩余票数2
    当前可售票数： 2
    购票1, 剩余票数1
    当前可售票数： 1
    目前剩余票数1, 购票2, 可售票数不足

显示结果是合理的。

## 二、synchronized 使用说明 ##

synchronized 一般涉及三种使用场景

1. 修饰实例方法，作用于当前对象实例，进入同步代码前要获得当前实例的锁（上述买票例子就是对实例方法 buyTicket() 加锁）

另外：一个线程正在访问一个对象实例的 synchronized 实例方法，那么其他线程不能访问该对象实例的其他 synchronized 方法，毕竟一个对象实例只有一把锁，当一个线程获取了该对象实例的锁之后，其他线程无法获取该对象实例的锁，所以无法访问该对象实例的其他synchronized实例方法

2. 修饰代码块，作用于对象实例，进入同步代码前要获得当前实例的锁，上述 Ticket  类改一下就是，如下：

public class Ticket {
        private Integer ticketNum;
    
        Ticket(int ticketNum) {
            this.ticketNum = ticketNum;
        }
    
        void buyTicket(int amount) {
            synchronized (ticketNum) {
                System.out.println("当前可售票数： " + ticketNum);
                if (ticketNum < amount) {
                    System.out.println("目前剩余票数" + ticketNum + ", 购票" + amount + ", 可售票数不足");
                } else {
                    ticketNum = ticketNum - amount;
                    System.out.println("购票" + amount + ", 剩余票数" + ticketNum);
                    if (ticketNum <= 0) {
                        System.out.println("票售罄");
                    }
                }
            }
    
        }
    }

上述代码是对 Integer 类型的 ticketNum对象实例加锁，大多时候推荐使用 this 替换 ticketNum，this 表示对当前实例加锁（到这里和实例方法加锁是一样的含义）

**同时，还可以把 ticketNum 换成 Ticket.class（类锁），这个在下面细说。**

3. 修饰静态方法，作用当前类，进入同步代码库前要获得给定类的锁（就是2中说的类锁）

这个很有意思，举个例子说明一下和实例方法加锁的区别

public class SynTwoMethod implements Runnable {
    
        static int i = 0;
    
        public synchronized void increase() {
            i++;
        }
    
    
        public static synchronized void increaseStatic() {
            i++;
        }
    
        public synchronized void increaseClass() {
            synchronized (SynTwoMethod.class) {
                i++;
            }
        }
    
        public void run() {
            for (int j = 0; j < 100000; j++) {
                increase();
    //            increaseStatic();
    //            increaseClass();
            }
        }
    
    }
    
    
    //测试
    
    public class SynTwoMethodTest {
        public static void main(String[] args) throws InterruptedException {
            SynTwoMethod synTwoMethod_1 = new SynTwoMethod();
            SynTwoMethod synTwoMethod_2 = new SynTwoMethod();
            Thread thread_1 = new Thread(synTwoMethod_1);
            Thread thread_2 = new Thread(synTwoMethod_2);
            thread_1.start();
            thread_2.start();
            thread_1.join();
            thread_2.join();
            System.out.println(synTwoMethod_1.i);
        }
    }

increase() 方法是实例方法加锁，increaseStatic() 是静态方法加锁，increaseClass() 是通过代码块对对象加锁；测试方法生成了同一对象的不同实例；在run() 方法里分别执行三种方法会发现：

increase 得到的结果是小于 200000，increaseStatic 和 increaseClass 得到的结果都是 200000。

结论：存在类锁的类，无论生成多少个实例，在执行加锁方法时都会单一执行；而实例加锁只对同一个实例有效。