java的锁，synchronized 关键字

最新推荐文章于 2025-10-14 17:36:46 发布

原创最新推荐文章于 2025-10-14 17:36:46 发布 · 694 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

多线程入门

java的锁，synchronized 关键字

1.synchronized 锁

锁又是线程中的一个概念，两个或者多个线程，可以通过锁来控制多个线程的执行。换句话说，多个线程竞争同一把锁，拿到锁的线程，先运行。其他没拿到锁的线程，等待，知道拿到锁，然后才能执行。上面的理解可以参考下面的代码：

public class TestSynchronized {
    public static void main(String[] args) {
        new TestSynchronized().testSynchronized();
    }
    
    public void testSynchronized(){
        Object lock = new Object(); //这是一个锁
        Thread threadA = new Thread(()->{
            synchronized (lock){  //锁住lock
                for (int i = 0; i < 3; i++) {
                    System.out.println("Current Thread "+Thread.currentThread().getName()+" running");
                }
            }
        },"A");
        Thread threadB = new Thread(()->{
            synchronized (lock){ //锁住lock
                for (int i = 0; i < 3; i++) {
                    System.out.println("Current Thread "+Thread.currentThread().getName()+" running");
                }
            }
        },"B");
        threadA.start();
        threadB.start();
    }
}

大家多次运行会发现代码的打印接口有两种可能：

结果一：

Current Thread A running
Current Thread A running
Current Thread A running
Current Thread B running
Current Thread B running
Current Thread B running

结果二：

Current Thread B running
Current Thread B running
Current Thread B running
Current Thread A running
Current Thread A running
Current Thread A running

不会出现第三种结果：随机打印 A和B。大家把 synchronized (lock)去掉，然后运行代码，会发现打印结果会出现第三种结果。

现在大家发现了synchronized 的作用了吧，就是锁住某个对象（上面的代码是锁住对象），或者某个方法，或者静态方法。其他两种我就不写代码了，大家可以自己试试。这里简单说下：

synchronized 作用在普通方法上，相当于锁对象。

synchronized 作用在静态方法上，相当于锁这个类。

2.用wait,notify释放锁

上面的代码我们看到了，一个对象用 synchronized 锁住了，必须等这个这个线程执行完，下一个线程才能拿到这个锁，执行代码。如果要让A和B的线程代码轮流执行，我们该如何处理呢？这样就需要调用对象的wait,notify方法了。废话不多说：代码如下：

public class TestSynchronized2 {
    public static void main(String[] args) {
        new TestSynchronized2().testSynchronized();
    }

    public void testSynchronized(){
        Object lock = new Object(); //这是一个锁
        Thread threadA = new Thread(()->{
            synchronized (lock){  //锁住lock
                for (int i = 0; i < 10; i++) {
                    System.out.println("Current Thread "+Thread.currentThread().getName()+" running");
                    try {
                        lock.wait(); //让出锁，让B执行
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.notify(); //唤醒线程B
                }
            }
        },"A");
        Thread threadB = new Thread(()->{
            synchronized (lock){ //锁住lock
                for (int i = 0; i < 10; i++) {
                    System.out.println("Current Thread "+Thread.currentThread().getName()+" running");
                    lock.notify(); //唤醒线程A
                    try {
                        lock.wait(); //让出锁，让A执行
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"B");
        threadA.start();

        try {
            Thread.sleep(100); //A先启动，然后B启动
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadB.start();
    }
}

打印结果如下：

Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running
Current Thread A running
Current Thread B running