synchronized锁的到底是谁???

原创已于 2024-11-04 23:30:54 修改 · 938 阅读

29 ·

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

GEO检测

标签

#java #jvm #windows #安全

于 2024-11-04 18:53:16 首次发布

操作系统专栏收录该内容

16 篇文章

订阅专栏

一.概述

相信学习过多线程线程安全问题的小伙伴都有类似的疑问吧? synchronized这个关键字说是在"加锁", 那么它到底锁的是谁呢??? 今天小编就来为大家解释这个问题. synchronized其实锁住的是它{ }中的代码块. 只有拿到锁对象的线程才能执行里面的代码块, 没拿到锁对象的线程不能执行synchronized{ }里面的代码块, 那么这个效果不就类似于把这个代码块"加锁"了吗.

我们在上一篇文章中提到, synchronized的基本语法如下:

synchronized (锁对象) {

//受保护语句.

}

可以理解为某个代码块如果被synchronized保包围, 那么此时某个线程如果想要执行这个"受保护的"代码块, 那么就必须先获取指定的锁对象. 如果有多个线程想要获取该锁对象, 那么就必须"阻塞等待", 等前一个线程释放锁对象之后, 才能拿到该锁对象. 这样一来就解决了由于线程并发而产生的指令错乱执行问题.

[注意]:

(1) 如果两个线程要获取的锁对象不是一个对象, 那还会发生"阻塞等待"吗? --> 显然不会. 因为, 我们说出现阻塞等待情况的原因是因为不同线程想要拿到同一个锁对象, 在这个过程中出现了"锁竞争", 一个线程要等待另一个线程执行完受保护语句释放锁对象, 才会出现阻塞等待的情况. 那么如果两个线程要拿的是不同的锁对象, 那么自然就不会出现锁竞争, 也就不会出现阻塞等待. 两个线程还是并发执行. 跟没加锁的效果完全一样.

(2) 如果两个线程一个加了synchronized, 另一个线程没加, 那么此时只有一个线程需要锁对象, 也不会出现锁竞争, 自然也就不会出现"阻塞等待"了.(这种情形也跟没加锁的效果一样)

我们可以用上篇文章中两个线程分别对count++5000次的那个例子来说明一下:

两个线程要获取的锁对象是两个对象:

public class Demo14 {
    private static int count = 0;
    public static Object obj1 = new Object();
    public static Object obj2 = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (obj1) {
                    count++; //t1线程对count++5000次
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (obj2) {
                    count++; //t2线程对count++5000次
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();//主线程对t1, t2 线程进行等待, 保证t1,t2线程执行完所有++操作后再打印count的值
        System.out.println("count = " + count);
    }
}

一个线程加synchronized, 另一个不加:

public class Demo14 {
    private static int count = 0;
    public static Object obj1 = new Object();
    public static Object obj2 = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (obj1) {
                    count++; //t1线程对count++5000次
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                count++; //t2线程对count++5000次
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();//主线程对t1, t2 线程进行等待, 保证t1,t2线程执行完所有++操作后再打印count的值
        System.out.println("count = " + count);
    }
}

我们看到, 这两种情况的结果都跟没加synchronized一样, 还是错误的. 所以, 必须两个线程都加synchronized并且指定同一个锁对象, 才能解决并发中出现的错误.

好了, 大概了解了synchronized的作用之后, 我们来看看synchronized的具体用法吧~

二. synchronized具体用法

1. 修饰代码块

synchronized修饰代码块的时候, 需要指定一个锁对象, 多个线程在"竞争"这个锁的时候出现阻塞等待.

import java.util.concurrent.TimeUnit;

public class Demo18 {
    public static void main(String[] args) {
        Data data = new Data();
        for (int i = 0; i < 3; i++) {
            new Thread(()->{ //这里创建3个线程并启动
                data.func();
            }).start();
        }
    }

}
class Data {
    public void func() {
        System.out.println("start ...");
        try {
            TimeUnit.SECONDS.sleep(1);  //休眠 1秒钟
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("End ...");
    }
}

我们来看上述代码, 没有加synchronized, 这个代码用for循环创建了3个线程并启动, 每个线程都调用func方法. 由于3个线程同时启动, 所以, 这个代码的运行结果应该是: 先同时打印出3个"start ...", 然后间隔1s, 再同时打印出3个"End ..."

我们可以看到, 结果确实是这样的.

那么如果我们此时对打印代码块加上synchronized呢?

import java.util.concurrent.TimeUnit;

public class Demo18 {
    public static void main(String[] args) {
        Data data = new Data();
        for (int i = 0; i < 3; i++) {
            new Thread(()->{ //这里创建3个线程并启动
                data.func();
            }).start();
        }
    }

}
class Data {
    public void func() {
        synchronized(this) {
            System.out.println("start ...");
            try {
                TimeUnit.SECONDS.sleep(1);  //休眠 1秒钟
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("End ...");
        }
    }
}

如上述代码, 我们给func中的代码块加上synchronized(this). this指的是谁? -- 我们之前说过, 谁调用func方法, this指的就是谁. 那么在这个代码中, 只有data调用了func, 所以data这个对象就是this. 那么, 每个线程创建之后, 都需要先拿到data对象, 才能执行synchronized里面的代码. 谁先拿到(那个线程先拿到是不确定的)谁就先执行, 没拿到的就阻塞等待, 等到前一个线程执行完synchronized中的代码, 释放锁对象data之后, 再去拿data, 执行自己线程的代码. 所以, 3个线程是轮流执行的. 打印出的结果应该是三组"start... + end...".