【Java】线程同步synchronized_java 线程同步synchonized-CSDN博客

本文链接：https://blog.csdn.net/qq_40839718/article/details/124370362

本文详细介绍了Java中的线程同步机制，通过售票问题展示了同步代码块和同步方法的使用，防止多线程环境下售票超卖。同步机制确保了在同一时刻只有一个线程能访问敏感数据，保证了数据的完整性。示例代码中，同步代码块和同步方法成功实现了线程间的协调，避免了资源冲突。总结了synchronized关键字的用法，包括同步方法的默认锁对象和同步代码块的锁对象选择。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程同步synchronized

1.线程同步机制

在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。即当一个线程在对内进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

2.同步具体方法

2.1 同步代码块

synchronized(对象) {					//得到对象的锁，才能操作同步代码
    需要被同步代码;
}

2.2 同步方法

public synchronized void m(String name){
     需要被同步的代码;
}

3.实际应用

3.1 问题描述

用线程同步的两种方法解决售票超卖问题

3.2 方法一：同步代码块

3.2.1 代码编写

public class SellTicketThread01 {
    public static void main(String[] args) {
        /*使用继承Thread类方式来售票*/
        System.out.println("====使用继承Thread类方式来售票====");
        System.out.println("====使用“同步代码块”方式来解决售票超卖问题====");
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket02 = new SellTicket01();
        SellTicket01 sellTicket03 = new SellTicket01();
        sellTicket01.start();
        sellTicket02.start();
        sellTicket03.start();
    }
}
class SellTicket01 extends Thread{
    private boolean bool = true;
    private static int ticketNum = 10;//让多个线程共享ticketNum
    public void sell() {
        synchronized (SellTicket01.class){   //要求多个线程的锁对象为同一个，此处不能用this，用this锁不住
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                bool = false;
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName()
                    + "售出一张票" + "剩余票数=" + (--ticketNum));
        }
    }
    @Override
    public void run() {
        while(bool){
           sell();
        }
    }
}

3.2.2 运行结果

在这里插入图片描述

3.3 方法二：同步方法

3.3.1 代码编写

public class SellTicketThread02 {
    public static void main(String[] args) {
        /*使用实现Runnable接口方式来售票*/
        System.out.println("====使用实现Runnable接口方式来售票====");
        System.out.println("====使用“同步方法”方式来解决售票超卖问题====");
        SellTicket02 sellTicket021 = new SellTicket02();
        Thread thread01 = new Thread(sellTicket021);
        Thread thread02 = new Thread(sellTicket021);
        Thread thread03 = new Thread(sellTicket021);
        thread01.start();
        thread02.start();
        thread03.start();
    }
}
class SellTicket02 implements Runnable{
    private boolean bool = true;
    private static int ticketNum = 100;//让多个线程共享ticketNum
    public synchronized void sell(){   //使用“同步方法”方式来解决售票超卖问题
        if(ticketNum<=0){
            System.out.println("售票结束...");
            bool = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()
                +"售出一张票"+"剩余票数="+(--ticketNum));
    }
    @Override
    public void run() {
        while(bool){
            sell();
        }
    }
}

3.3.2 运行结果

在这里插入图片描述

4.总结

关键字synchronized来与对象的互斥锁联系，每个对象都对应一个可称为“互斥锁”的标记。
(1) 同步方法如果没有使用satic修饰，默认锁对象为this；
(2) 同步方法如果使用static修饰，默认锁对象为当前类.class
(3) 要求多个线程的锁对象为同一个，即用当前类.class，不能用this。