【JavaEE初阶】 synchronized关键字详解

简介: 【JavaEE初阶】 synchronized关键字详解


本文重点:

  • synchronized 的特性
  • synchronized 使用示例
  • ava 标准库中的线程安全类

🌴synchronized 的特性

🚩互斥

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到

同一个对象 synchronized 就会阻塞等待.

  • 进入 synchronized 修饰的代码块, 相当于 加锁
  • 退出 synchronized 修饰的代码块, 相当于 解锁

    synchronized用的锁是存在Java对象头里的。

可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 “锁定” 状态(类似于厕所的 “有人/无人”).

  • 如果当前是 “无人” 状态, 那么就可以使用, 使用时需要设为 “有人” 状态.
  • 如果当前是 “有人” 状态, 那么其他人无法使用, 只能排队

后面排队的人我们可以称为“阻塞等待”

阻塞等待:针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁.

注意:

  • 上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 “唤醒”. 这也就是操作系统线程调度的一部分工作.
  • 假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B和 C 都在阻塞队列中排队等待.但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则

补充:synchronized的底层是使用操作系统的mutex lock实现的

🚩可重入

synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题

那么什么是可重入?怎么自己把自己锁死呢?

理解 “把自己锁死”:

一个线程没有释放锁, 然后又尝试再次加锁

  • 按照之前对于锁的设定, 第二次加锁的时候, 就会阻塞等待.
  • 直到第一次的锁被释放, 才能获取到第二个锁.
  • 但是释放第一个锁也是由该线程来完成, 结果这个线程已经躺平了, 啥都不想干了, 也就无法进行解锁操作.
  • 这时候就会死锁

举个例子:

一个滑稽老铁去上厕所,反锁厕所们后,然后不小心一个闪现出来了,还失忆了,这时候厕所没人,但是处于锁的状态,后面等待的人无法进入

这样的锁称为不可重入锁

Java 中的== synchronized 是可重入锁==, 因此没有上面的问题

代码示例

public class Counter {
  public int count = 0;
  synchronized void increase() {
    count++;
  }
  synchronized void increase2() {
    increase();
  }
}

在上面的代码中,

  • increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对== this 当前对象==加锁的.
  • 在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释放, 相当于连续加两次锁)
  • 这个代码是完全没问题的.

因为 synchronized 是可重入锁

在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息.

  • 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增.
  • 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

🍀synchronized 的使用

synchronized 本质上要修改指定对象的 “对象头”. 从使用角度来看, synchronized 也势必要搭配一个具
体的对象来使用

synchronized的使用方法可以分为以下三种:

🚩直接修饰普通方法

锁是当前实例对象 ,进入同步代码前要获得当前实例的锁

锁的 SynchronizedDemo对象

public class SynchronizedDemo {
  public synchronized void methond() {
  }
}

使用举例:

多个线程访问同一个对象的同一个方法

public class synchronizedTest implements Runnable {
    //共享资源
    static int i =0;
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run(){
        for (int j =0 ; j<10000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        synchronizedTest test = new synchronizedTest();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

运行结果如下:

分析:当两个线程同时对一个对象的一个方法进行操作,只有一个线程能够抢到锁。因为一个对象只有一把锁,一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,就不能访问该对象的其他synchronized实例方法,需要等到对象被释放后才能获取,但是在对象没有被释放前,其他线程可以访问非synchronized修饰的方法

🚩修饰静态方法

锁是当前类的class对象 ,进入同步代码前要获得当前类对象的锁

锁的 SynchronizedDemo 类的对象

public class SynchronizedDemo {
  public synchronized static void method() {
  
    }
}

使用举例

public class synchronizedTest3 implements Runnable {
    //共享资源
    static int i = 0;
    /**
     * synchronized 修饰静态方法
     */
    public static synchronized void increase() {
        i++;
    }
    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            increase();
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new synchronizedTest3());
        Thread t2 = new Thread(new synchronizedTest3());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(synchronizedTest3.i);
    }
}

结果如下:

分析:由例子可知,两个线程实例化两个不同的对象,但是访问的方法是静态的,两个线程发生了互斥(即一个线程访问,另一个线程只能等着),因为静态方法是依附于类而不是对象的,当synchronized修饰静态方法时,锁是class对象

🚩 修饰代码块

同步方法块,锁是括号里面的对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁

  • 锁当前对象
public class SynchronizedDemo {
  public void method() {
    synchronized (this) {
    
    }
  }
}
  • 锁类对象
public class SynchronizedDemo {
  public void method() {
    synchronized (SynchronizedDemo.class) {
    
    }
  }
}

🧭synchronized 的使用总结:

我们重点要理解,synchronized 锁的是什么. 两个线程竞争同一把锁, 才会产生阻塞等待

两个线程分别尝试获取两把不同的锁, 不会产生竞争.

🎍Java 标准库中的线程安全类

Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施.

  • ArrayList
  • LinkedList
  • HashMap
  • TreeMap
  • HashSet
  • TreeSet
  • StringBuilde

但是还有一些是线程安全的. 使用了一些锁机制来控制

  • Vector (不推荐使用)
  • HashTable (不推荐使用)
  • ConcurrentHashMap
  • StringBuffer

不推荐使用的原因是:当你使用这些类时,每一次都会伴随加锁操作,如果该操作不需要加锁,则就会造成时间浪费。

注意String还有的虽然没有加锁, 但是不涉及 “修改”, 仍然是线程安全的

⭕总结

关于《【JavaEE初阶】 synchronized关键字详解》就讲解到这儿,感谢大家的支持,欢迎各位留言交流以及批评指正,如果文章对您有帮助或者觉得作者写的还不错可以点一下关注,点赞,收藏支持一下!

相关文章
|
6月前
|
安全 算法 Java
多线程(初阶四:synchronized关键字)
多线程(初阶四:synchronized关键字)
51 0
|
6月前
|
Java 编译器
【JAVA】volatile 关键字的作用
【JAVA】volatile 关键字的作用
|
6月前
|
Java 程序员 编译器
【JavaEE初阶】 Synchronized 原理详解
【JavaEE初阶】 Synchronized 原理详解
|
6月前
|
存储 安全 Java
【JavaEE初阶】 volatile关键字 与 wait()方法和notify()方法详解
【JavaEE初阶】 volatile关键字 与 wait()方法和notify()方法详解
|
6月前
|
安全 Java 编译器
【JavaEE初阶】 线程安全
【JavaEE初阶】 线程安全
|
6月前
|
Java 程序员 调度
【JavaEE初阶】 Thread类及常见方法
【JavaEE初阶】 Thread类及常见方法
|
传感器 缓存 安全
【Java面试】能说说你对volatile关键字的理解吗?
【Java面试】能说说你对volatile关键字的理解吗?
120 0
【Java面试】能说说你对volatile关键字的理解吗?
|
缓存 人工智能 安全
【Java基础】volatile关键字
volatile 是一个Java关键字,可以用来修饰变量,volatile也被称为轻量级的synchronized,运行时开销比 synchronized更小。
|
Java
synchronized关键字的底层原理你了解吗?
synchronized关键字是Java中用于实现线程同步的关键字,它可以用于修饰方法或代码块。synchronized关键字的底层原理涉及到Java内存模型和对象监视器的概念。
103 0
|
存储 Java
Java面试题之synchronized关键字原理以及锁相关
录 一、Java中锁的概念 二、同步关键字synchronized特性 1、锁消除示例 2、锁粗化示例 三、synchronized关键字原理 1、关于Mark Word 2、锁的状态变化 (1) 无锁 → 轻量级锁 (2) 轻量级锁 → 重量级锁 (3) 关于偏向锁(加锁之后不解锁,针对单线程) (4) 完整的锁升级过程
Java面试题之synchronized关键字原理以及锁相关