synchronized

Junfeng Tang

已于 2023-10-13 08:08:16 修改

阅读量67

点赞数

分类专栏： java基础文章标签： java 开发语言

于 2023-10-12 14:47:44 首次发布

本文链接：https://blog.csdn.net/qq_26347283/article/details/133790578

版权

java基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

synchronized

synchronized是 Java 编程语言中的一个关键字，用于提供线程同步。在多线程编程中，synchronized可以确保在同一时间只有一个线程可以访问受保护的代码区域，从而避免数据的不一致性和其他并发问题。

使用方法

synchronized关键字通常使用在下面四个地方：

修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

    //修饰实例方法，锁的实例对象
	public synchronized void demo1() {
        System.out.println("junfeng");
    }
	//修饰静态方法，锁的类对象
    public synchronized static void demo2() {
        System.out.println("junfeng");
    }

    public void demo3() {
        //锁的实例对象
        synchronized (this) {
            System.out.println("junfeng");
        }
    }

    public void demo4() {
        //锁的类对象
        synchronized (SychronizedTest.class) {
            System.out.println("junfeng");
        }
    }

同步方法

同步普通方法

    public static void main(String[] args) {
        for (int i = 0; i < 7; i++) {
            MyThread myThread = new MyThread();
            Thread thread = new Thread(myThread);
            thread.start();
        }
    }

package com.junfeng.manage.test;

public class MyThread implements Runnable {
    @Override
    public void run() {
        printTest();
    }

    private synchronized void printTest() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "~~~~" + System.currentTimeMillis());
    }
}

打印结果：

Thread-6~~~~1697077107016
Thread-0~~~~1697077107016
Thread-5~~~~1697077107016
Thread-2~~~~1697077107016
Thread-3~~~~1697077107016
Thread-4~~~~1697077107016
Thread-1~~~~1697077107016

上面代码执行一下子就打印出结果，说明多个线程之间是没有阻塞的。若是将printTest方法改成静态方法

同步静态方法

package com.junfeng.manage.test;

public class MyThread implements Runnable {
    @Override
    public void run() {
        printTest();
    }

    private synchronized static void printTest() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "~~~~" + System.currentTimeMillis());
    }
}

打印结果：

Thread-0~~~~1697078155367
Thread-6~~~~1697078156382
Thread-5~~~~1697078157383
Thread-4~~~~1697078158385
Thread-3~~~~1697078159387
Thread-2~~~~1697078160395
Thread-1~~~~1697078161401

发现打印每个一秒打印一次，说明线程之间是阻塞的。

综上代码执行结果，说明sychronized修饰普通方法时，其修饰的是方法实例对象；而sychronized修饰静态方法时，其修饰的为类对象。

同步代码块

同上同理，sychronized修饰this时，其修饰的是方法实例对象；而sychronized修饰MyThread.class时，其修饰的为类对象。

锁升级

在Java中，synchronized锁的升级是指锁的状态从无锁状态逐渐升级为偏向锁、轻量级锁和重量级锁的过程。

首先看看32位JVM中Mark Word存储结构：
在这里插入图片描述
sychronized锁升级详细过程如下图：

原子性、可见性、有序性

原子性： synchronized是通过monitorenter和monitorexit这两个字节码指令来实现原子性的。
可见性：对变量调用的unlock解锁这个操作规定，放开对某个变量的锁的之前，需要把这个变量从缓存更新到主内存，因此它也具有可见性。
有序性：因为在一个线程内部，他不管怎么指令重排，他都是as-if-serial的，也就是说单线程即使重排序之后的运行结果和串行运行的结果是一样的，是类似串行的语义。