java——synchronized关键字（1）

最新推荐文章于 2024-07-16 19:38:34 发布
最新推荐文章于 2024-07-16 19:38:34 发布
阅读量144 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmx8112/article/details/85786907
版权

 

 

一句话形容Synchronized关键字的作用：能够保证同一时刻，最多只有一个线程执行该段代码，已达到并发安全的效果。

一、对象锁

1、代码块：

package com.example.springwebfluxtest.synchronize;

public class SynchronizedObjectCodeBlock2 implements Runnable {
    static SynchronizedObjectCodeBlock2 instance = new SynchronizedObjectCodeBlock2();

    @Override
    public void run() {
        synchronized (this){
            System.out.println("我是对象锁的代码块形式"+"我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"运行结束");
        }

    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }
}

运行结果：（保证串行执行）

我是对象锁的代码块形式我叫Thread-1
Thread-1运行结束
我是对象锁的代码块形式我叫Thread-0
Thread-0运行结束
finished

 

package com.example.springwebfluxtest.synchronize;

public class SynchronizedObjectCodeBlock2 implements Runnable {
    static SynchronizedObjectCodeBlock2 instance = new SynchronizedObjectCodeBlock2();
    Object lock1 = new Object();
    Object lock2 = new Object();
    @Override
    public void run() {
        synchronized (lock1){
            System.out.println("我是lock1"+"我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"lock1运行结束");
        }
        synchronized (lock2){
            System.out.println("我是lock2"+"我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"lock2运行结束");
        }

    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }
}

运行结果：
我是lock2我叫Thread-0        几乎同时
我是lock1我叫Thread-1

我是lock1我叫Thread-0
Thread-0lock1运行结束
我是lock2我叫Thread-0
我是lock1我叫Thread-1
Thread-0lock2运行结束
Thread-1lock1运行结束
我是lock2我叫Thread-1
Thread-1lock2运行结束
finished

调试技巧：

切换线程

2、普通方法：

package com.example.springwebfluxtest.synchronize;

public class SynchronizedObjectMehod3 implements Runnable {
    static SynchronizedObjectMehod3 instance = new SynchronizedObjectMehod3();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }
    @Override
    public void run() {
        method();
    }
    public synchronized void method(){
        System.out.println("我是对象锁的方法修饰符形式"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
}

运行结果：

我是对象锁的方法修饰符形式我叫Thread-1
Thread-1运行结束
我是对象锁的方法修饰符形式我叫Thread-0
Thread-0运行结束
finished

二、类锁

1、synchronized加在static方法上

package com.example.springwebfluxtest.synchronize;

public class SynchronizedClassStatic4 implements Runnable {
    static SynchronizedClassStatic4 instance1 = new SynchronizedClassStatic4();
    static SynchronizedClassStatic4 instance2 = new SynchronizedClassStatic4();
    @Override
    public void run() {
        method();
    }
    public static synchronized void method(){
        System.out.println("我是类锁的静态方法"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }
}

运行结果：

我是类锁的静态方法我叫Thread-1
Thread-1运行结束
我是类锁的静态方法我叫Thread-0
Thread-0运行结束
finished

2、synchronized（*。class）代码块

package com.example.springwebfluxtest.synchronize;

public class SynchronizedClassClass implements Runnable {
    static SynchronizedClassClass instance1 = new SynchronizedClassClass();
    static SynchronizedClassClass instance2 = new SynchronizedClassClass();
    @Override
    public void run() {
        method();
    }
    public void method(){
        synchronized(SynchronizedClassClass.class){
            System.out.println("我是类锁*.class"+"我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"运行结束");
        }

    }
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }
}

运行结果：

我是类锁*.class我叫Thread-1
Thread-1运行结束
我是类锁*.class我叫Thread-0
Thread-0运行结束
finished

多线程访问同步方法的7种情况

4、同时访问同步与非同步方法：非同步方法不受到影响：

package com.example.springwebfluxtest.synchronize;

public class SynchronizedYesAndNo6 implements Runnable {
    static SynchronizedYesAndNo6 instance  = new SynchronizedYesAndNo6();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method();
        }else{
            method2();
        }

    }
    public synchronized void method(){
        System.out.println("我是同步方法"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public void method2(){
        System.out.println("我是非同步方法"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }

}

运行结果：

我是非同步方法我叫Thread-1
我是同步方法我叫Thread-0
Thread-0运行结束
Thread-1运行结束
finished

package com.example.springwebfluxtest.synchronize;

public class SynchronizedDifferentMethod7 implements Runnable {
    static SynchronizedDifferentMethod7 instance  = new SynchronizedDifferentMethod7();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method();
        }else{
            method2();
        }

    }
    public synchronized void method(){
        System.out.println("我是同步方法1"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public synchronized void method2(){
        System.out.println("我是同步方法2"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }

}

运行结果：

我是同步方法1我叫Thread-0
Thread-0运行结束
我是同步方法2我叫Thread-1
Thread-1运行结束
finished


package com.example.springwebfluxtest.synchronize;

public class SynchronizedStaticAndNormal8 implements Runnable {
    static SynchronizedStaticAndNormal8 instance  = new SynchronizedStaticAndNormal8();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method();
        }else{
            method2();
        }

    }
    public synchronized static void method(){
        System.out.println("我是static同步方法1"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public synchronized void method2(){
        System.out.println("我非static是同步方法2"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }

}

运行结果：

我非static是同步方法2我叫Thread-1
我是static同步方法1我叫Thread-0
Thread-1运行结束
Thread-0运行结束
finished

package com.example.springwebfluxtest.synchronize;

public class SynchronizedException9 implements Runnable {
    static SynchronizedException9 instance  = new SynchronizedException9();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method();
        }else{
            method2();
        }

    }
    public synchronized  void method(){
        System.out.println("我是同步方法1"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
            throw new Exception();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public synchronized void method2(){
        System.out.println("我是同步方法2"+"我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive()||t2.isAlive()){

        }
        System.out.println("finished");
    }

}

运行结果（有问题）：

我是同步方法2我叫Thread-1
Thread-1运行结束
我是同步方法1我叫Thread-0
java.lang.Exception
    at com.example.springwebfluxtest.synchronize.SynchronizedException9.method(SynchronizedException9.java:18)
    at com.example.springwebfluxtest.synchronize.SynchronizedException9.run(SynchronizedException9.java:8)
    at java.lang.Thread.run(Thread.java:748)
Thread-0运行结束
finished

视频的结果：

核心思想：

目前我进入到了一个被synchronized修饰的方法，而在这个方法里调用了另外一个没有被synchronized修饰的方法，这个时候线程不是安全的。

synchronized的性质：

1、可重入

情况1：

package com.example.springwebfluxtest.synchronize;

/**
 * 可重入粒度测试：递归调用本方法
 */
public class SynchronizedRecursion9 {
     int a = 0;
    public static void main(String[] args) {
        SynchronizedRecursion9 synchronizedRecursion9 = new SynchronizedRecursion9();
        synchronizedRecursion9.method1();
    }
    private synchronized void method1(){
        System.out.println("这是method1,a="+a);
        if(a == 0){
            a++;
            method1();
        }
    }
}

运行结果：

这是method1,a=0
这是method1,a=1

情况2：

package com.example.springwebfluxtest.synchronize;

/**
 * 可重入粒度测试2：调用类内部其他的方法
 */
public class SynchronizedRecursion11 {
    public static void main(String[] args) {
        SynchronizedRecursion11 synchronizedRecursion9 = new SynchronizedRecursion11();
        synchronizedRecursion9.method1();
    }
    public synchronized void method1(){
        System.out.println("我是mthod1()");
        method2();
    }
    private synchronized void method2(){
        System.out.println("我是method2");
    }
}

运行结果：

我是mthod1()
我是method2

情况3：

结果

我是子类方法
我是父类方法

package com.example.springwebfluxtest.synchronize;

import javax.xml.bind.SchemaOutputResolver;

/**
 * 可重入粒度测试3：调用父类方法
 */
public class SynchronizedRecursion12 {
   public synchronized void doSomething(){
       System.out.println("我是父类方法");
   }
}
class TestClass extends SynchronizedRecursion12{
    public synchronized void doSomething(){
        System.out.println("我是子类方法");
        super.doSomething();
    }

    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        testClass.doSomething();
    }
}
键近思远
关注
【后端】 java基础（5.8）java高级基础之线程——synchronized关键字
03-29
java基础（5.8）java高级基础之线程——synchronized关键字 本章主要讲线程，至于带上进程的原因是为了方便大家对进程和线程有个概念（咳，主要原因是鄙人也不太会进程~）。 首先简单说下我个人对进程和线程的理解。...
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
Java 基础 —— synchronized 关键字详解
IT__learning的博客
11-03 1932
一、synchronized 三大特性 在多线程的环境下，多个线程同时访问共享资源会出现一些问题，而 synchronized 关键字则是用来保证线程同步的。 synchronized 关键字可以保证并发编程的三大特性：原子性、可见性、有序性。而 volatile关键字只能保证可见性和有序性，不能保证原子性，也称为是轻量级的 synchronized。 （1）原子性：一个或多个操作要么全部执行成功，要么全部执行失败。synchronized 关键字可以保证只有一个线程拿到锁，访问共享资源。 （2）可见性：
Java并发——synchronized关键字解读
WanguideShenghuo的博客
03-22 934
synchronized表示同步的，指同一时刻，一个同步代码块只能被一个线程所获取并执行
Java并发编程(5) —— synchronized关键字详解
m0_56602092的博客
04-07 385
在上一篇中我们提到了volatile关键字可通过插入内存屏障的方式来保证变量的可见性（每次使用都到主存中进行读取）和有序性（不允许指令重排序），但是volatile关键字不保证对变量复合操作的原子性，例如i++操作在jvm层面实际上是通过多条指令操作完成，而若用synchronized 关键字将操作代码块包起来，则同一时刻只有一个线程能进入进行操作，这就保证了原子性。 在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。这是因为监视器锁（monitor）是依赖于底层的操作系统的
Java并发——synchronized关键字
雪月清的博客
12-20 587
详解Java中的关键字synchronized的作用范围、底层实现、锁升级的过程、优缺点
JAVA并发编程——synchronized关键字
L170311的博客
03-21 1076
Java语言为了解决并发编程中存在的原子性、可见性和有序性问题，提供了一系列和并发处理相关的关键字，比如volatilefinalconcurren包等。关键字在需要原子性、可见性和有序性这三种特性的时候都可以作为其中一种解决方案，看起来是“万能”的。的确，大部分并发控制操作都能使用synchronized来完成。海明威在他的《午后之死》说过的：“冰山运动之雄伟壮观，是因为他只有八分之一在水面上。”对于程序员来说，只是个关键字而已，用起来很简单。
Java并发编程——Synchronized关键字解析
想着百万年薪努力的小赵
08-31 231
  首先，让我们了解下这个关键字的作用，或者说是解决了什么问题   解决可见性、原子性、有序性问题   然后，再去看它是怎么使用的： 简单介绍： synchronized是Java中的关键字，是一种同步锁。 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
多线程——synchronized关键字
comerun的博客
07-16 1338
在我们的多线程中，我们还需要去了解一个很重要的关键字，那就是synchronized关键字，那我们就来具体聊一聊为什么要创建这样一个关键字吧！
同步控制——synchronized关键字
qq_34459728的博客
03-09 1442
同步是java中一个很重要的知识点，也是比较难以理解的知识点。经常在学会了，学忘了，学废了之间循环，抽点时间系统的整理一下同步的知识点，梳理一下逻辑 synchronized关键字 先看看这个synchronized关键字，synchronized有五种比较常用的方法 修饰代码块 修饰变量 修饰普通方法 修饰静态方法 修饰类 先来看看修饰代码块 ...
Java关键字——synchronized
weixin_42547014的博客
07-21 2960
什么是synchronize 如何使用 底层原理 做过那些优化 对象在内存中 用户态？内核态？ 为什么效率低 一、认识 Synchronized synchornized 是 Java 中的一个关键字，解决的是多个线程之间访问资源的同步性，synchronized 关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 重量级锁：其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线.
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1527
synchronized关键字到底锁的是谁？
Java——volatile关键字详解
12-21
Java中的`volatile`关键字是一个非常重要的并发控制工具，它提供了比`synchronized`关键字更为轻量级的同步机制。`volatile`关键字的主要作用是确保多线程环境下的可见性和禁止指令重排序，但不保证原子性。 **...
沈阳建筑大学在河南2021-2024各专业最低录取分数及位次表.pdf
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
贵州茅台数据(1).xlsx
09-16
贵州茅台数据(1)
cwgl_jy1301.doc
09-16
cwgl_jy1301.doc
java-ssm+jsp游戏账号交易系统实现源码(项目源码-说明文档)
09-16
登录进入游戏账号交易系统可以查看系统用户管理，用户信息管理，海洋新闻管理，海鲜信息管理，购买信息管理，订退单信息管理和系统管理首页、个人中心、卖家管理、用户管理、游戏类别管理、手续费用管理、地下城与勇士管理、地下城账号购买、地下城账号换绑管理、地下城账号申诉管理、地下城私信聊天管理、地下城私信回复管理、英雄联盟管理、英雄联盟购买管理 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：jsp 关键技术：jsp、spring、ssm、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
java-ssm+jsp医院资产管理系统实现源码(项目源码-说明文档)
09-16
登陆系统后，可以查看主页、个人中心、员工管理、供应商管理、设备类型管理、仪器设备管理、设备采购管理、设备入库管理、设备申请管理、检修信息管理等功能 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：jsp 关键技术：jsp、spring、ssm、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
一款基于fofa根据域名或fofa语法收集C段分布数量的工具_Ceyes.zip
最新发布
09-16
一款基于fofa根据域名或fofa语法收集C段分布数量的工具_Ceyes
深入解析：Java实习生面试热门话题——synchronized与ReentrantLock对比
synchronized是Java中的内置关键字，实现了一种独占式的悲观锁，其核心是JVM层面的机制。它利用monitor（监视器）对象来管理线程的访问权限。当一个线程进入同步代码块或方法时，会尝试获取该对象的monitor，只有当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值