面试常问synchronized 和 static synchronized区别

最新推荐文章于 2023-05-26 18:10:55 发布
最新推荐文章于 2023-05-26 18:10:55 发布
阅读量96 收藏
点赞数
分类专栏： 锁 synchronized 文章标签： synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/want_you_gogo/article/details/103319517
版权

面试题：

  • 1、线程1访问AClass.staticWrite()方法时，线程2能访问ACass.staticRead()方法吗？
  • 2、线程1访问new AClass().staticWrite()方法时，线程2能访问new ACass().staticRead()方法吗？
  • 3、线程1访问AClass.staticWrite()方法时，线程2能访问new ACass().staticRead()方法吗？
  • 4、AClass a = new AClass(); 线程1访问a.write()方法时，线程2能访问a.read()方法吗？
  • 5、AClass a = new AClass();AClass b = new AClass(); 线程1访问a.write()方法时，线程2能访问b.read()方法吗？
  • 6、线程1访问AClass.staticWrite()方法时，线程2能访问new AClass().read()方法吗？
  • 7、线程1访问new AClass().staticWrite()方法时，线程2能访问new AClass().read()方法吗？

验证代码：

package com.util.countDownLatch;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.junit.After;
import org.junit.Test;

/**
 * <p>@Desc：synchronized与static synchronized区别</p>
 * 面试问题：
 * 1、线程1访问AClass.staticWrite()方法时，线程2能访问ACass.staticRead()方法吗？
 * 2、线程1访问new AClass().staticWrite()方法时，线程2能访问new ACass().staticRead()方法吗？
 * 3、线程1访问AClass.staticWrite()方法时，线程2能访问new ACass().staticRead()方法吗？
 * 4、AClass a = new AClass(); 
 *    线程1访问a.write()方法时，线程2能访问a.read()方法吗？
 * 5、AClass a = new AClass();AClass b = new AClass();
 *    线程1访问a.write()方法时，线程2能访问b.read()方法吗？
 * 6、线程1访问AClass.staticWrite()方法时，线程2能访问new AClass().read()方法吗？
 * 7、线程1访问new AClass().staticWrite()方法时，线程2能访问new AClass().read()方法吗？
 */
public class TestSynchronizedAndStaticSynchronized {

	// CountDownLatch相当于计数器，当所有都准备好了，再一起执行，模仿真实并发
	CountDownLatch mainLatch = new CountDownLatch(1);// 主线程用于等待子线程达到一定数量后并发执行
	CountDownLatch threadDownLatch = new CountDownLatch(2);// 定义子线程执行次数
	// 线程池
	private final ExecutorService executorService = Executors.newFixedThreadPool(2);

	// 1、线程1访问AClass.staticWrite()方法时，线程2能访问ACass.staticRead()方法吗？(结论：不能)
	@Test
	public void test1() throws InterruptedException {
		executorService.submit(new Task(mainLatch, threadDownLatch,"AClass","static","write", null));
		executorService.submit(new Task(mainLatch, threadDownLatch,"AClass","static","read", null));

		// 子线程达到并发要求，主线程放行，同时子线程执行函数
		mainLatch.countDown();
	}


	// 2、线程1访问new AClass().staticWrite()方法时，线程2能访问new ACass().staticRead()方法吗？(结论：不能)
	@Test
	public void test2() throws InterruptedException {
		executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","static","write", null));
		executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","static","read", null));

		// 子线程达到并发要求，主线程放行，同时子线程执行函数
		mainLatch.countDown();
	}

	// 3、线程1访问AClass.staticWrite()方法时，线程2能访问new ACass().staticRead()方法吗？(结论：不能)
    @Test
    public void test3() throws InterruptedException {
        executorService.submit(new Task(mainLatch, threadDownLatch,"AClass","static","write", null));
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","static","read", null));

        // 子线程达到并发要求，主线程放行，同时子线程执行函数
        mainLatch.countDown();
    }

    // 4、AClass a = new AClass(); 线程1访问a.write()方法时，线程2能访问a.read()方法吗？(结论：不能)
    @Test
    public void test4() throws InterruptedException {
	    AClass a = new AClass();
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","noStatic","write",a));
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","noStatic","read",a));

        // 子线程达到并发要求，主线程放行，同时子线程执行函数
        mainLatch.countDown();
    }

    // 5、AClass a = new AClass();AClass b = new AClass(); 线程1访问a.write()方法时，线程2能访问b.read()方法吗？(结论：能)
    @Test
    public void test5() throws InterruptedException {
        AClass a = new AClass();
        AClass b = new AClass();
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","noStatic","write",a));
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","noStatic","read",b));

        // 子线程达到并发要求，主线程放行，同时子线程执行函数
        mainLatch.countDown();
    }

    // 6、线程1访问AClass.staticWrite()方法时，线程2能访问new AClass().read()方法吗？(结论：能)
    @Test
    public void test6() throws InterruptedException {
        executorService.submit(new Task(mainLatch, threadDownLatch,"AClass","static","write", null));
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","noStatic","read", null));

        // 子线程达到并发要求，主线程放行，同时子线程执行函数
        mainLatch.countDown();
    }

    // 6.1、线程1访问AClass.staticWrite()方法时，线程2能访问AClass.read()方法吗？(结论：能)
    @Test
    public void test6_1() throws InterruptedException {
        executorService.submit(new Task(mainLatch, threadDownLatch,"AClass","static","write", null));
        executorService.submit(new Task(mainLatch, threadDownLatch,"AClass","noStatic","read", null));

        // 子线程达到并发要求，主线程放行，同时子线程执行函数
        mainLatch.countDown();
    }

    // 7、线程1访问new AClass().staticWrite()方法时，线程2能访问new AClass().read()方法吗？(结论：能)
    @Test
    public void test7() throws InterruptedException {
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","static","write", null));
        executorService.submit(new Task(mainLatch, threadDownLatch,"new AClass","noStatic","read", null));

        // 子线程达到并发要求，主线程放行，同时子线程执行函数
        mainLatch.countDown();
    }

	@After
	public void tearDown() {
		try{
			// 等待子线程全部执行完成，在finally中执行收尾工作
			threadDownLatch.await();
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			System.out.println("执行结束，释放线程池!");
			executorService.shutdown();
		}
	}

}

/**
 * 线程1：write的任务
 */
class Task implements Runnable {
	private CountDownLatch mainLatch;// 主线程的发令枪
	private CountDownLatch countDownLatch;// 子线程的发令枪
	private String isNewObject;// 对象是否是创建
	private String isStaticMethod;// 是否调用静态方法
	private String whichMethod;// 调用的是write方法还是read方法
    private AClass clazz;
	public Task(CountDownLatch mainLatch, CountDownLatch countDownLatch, String isNewObject, String isStaticMethod, String whichMethod, AClass clazz) {
		this.mainLatch = mainLatch;
		this.countDownLatch = countDownLatch;
		this.isNewObject = isNewObject;
		this.isStaticMethod = isStaticMethod;
		this.whichMethod = whichMethod;
		this.clazz = clazz;
	}

	@SuppressWarnings("static-access")
	@Override
	public void run() {
		try {
			//System.out.printf("当前线程%s-------阻塞中--------", Thread.currentThread().getName());
			mainLatch.await();// 一直阻塞当前线程，直到计时器的值为0,保证同时并发
			if("AClass".equals(isNewObject)) {// 工具类调用
				if("static".equals(isStaticMethod)) {// 调用静态synchronized方法
					if("write".equals(whichMethod)) {// 调用write方法
						AClass.staticWrite();
					}else {// 调用read方法
						AClass.staticRead();
					}
				}
			}else {// new对象调用
                if (clazz != null){
                    if("static".equals(isStaticMethod)) {// 调用静态synchronized方法
                        if("write".equals(whichMethod)) {// 调用write方法
                            clazz.staticWrite();
                        }else {// 调用read方法
                            clazz.staticRead();
                        }
                    }else {// 调用非静态synchronized方法
                        if("write".equals(whichMethod)) {// 调用write方法
                            clazz.write();
                        }else {// 调用read方法
                            clazz.read();
                        }
                    }
                }else{
                    if("static".equals(isStaticMethod)) {// 调用静态synchronized方法
                        if("write".equals(whichMethod)) {// 调用write方法
                            new AClass().staticWrite();
                        }else {// 调用read方法
                            new AClass().staticRead();
                        }
                    }else {// 调用非静态synchronized方法
                        if("write".equals(whichMethod)) {// 调用write方法
                            new AClass().write();
                        }else {// 调用read方法
                            new AClass().read();
                        }
                    }
                }
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			countDownLatch.countDown();
		}
	}
}

class AClass {
	public static synchronized void staticWrite() throws InterruptedException {
		System.out.println("public static synchronized void staticWrite is running start");
		Thread.sleep(3000L);
		System.out.println("public static synchronized void staticWrite is running end");
	}

	public static synchronized void staticRead() throws InterruptedException {
		System.out.println("public static synchronized void staticRead is running start");
		Thread.sleep(5000L);
		System.out.println("public static synchronized void staticRead is running end");
	}

	public synchronized void write() throws InterruptedException {
		System.out.println("public synchronized void write is running start");
		Thread.sleep(8000L);
		System.out.println("public synchronized void write is running end");
	}

	public synchronized void read() throws InterruptedException {
		System.out.println("public synchronized void read is running start");
		Thread.sleep(10000L);
		System.out.println("public synchronized void read is running end");
	}

}

概述

通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）。

区别

synchronized关键字

synchronized作用是对类的当前实例（对象）加锁。可以使用synchronized关键字来标记一个方法或者代码块，当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，这个线程便获得了该对象的锁，其他线程暂时无法访问这个方法，只有等待这个方法执行完毕或者代码块执行完毕，这个线程才会释放该对象的锁（Java 并发编程）。
synchronized代码块【synchronized（synObject）】使用起来比synchronized方法要灵活得多。因为也许一个方法中只有一部分代码只需要同步，如果此时对整个方法用synchronized进行同步，会影响程序执行效率。而使用synchronized代码块就可以避免这个问题（同步对象或类属性），synchronized代码块可以实现只对需要同步的地方进行同步。
与Lock的区别：1. synchronized是Java语言的关键字，因此是内置特性，Lock是一个类（java.util.concurrent.locks包），通过这个类可以实现同步访问；2. synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用。Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

static synchronized：

每个类有一个锁，它可以用来控制对static数据成员的并发访问。访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁。static synchronized控制类的所有实例（对象）的访问（相应代码块）。synchronized相当于 this.synchronized，static synchronized相当于类.synchronized。

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的（第6个例子）。

结论

A: synchronized static是某个类的范围，synchronized static cSync{}防止多个线程中多个实例同时访问这个 类中的synchronized static 方法。它可以对类的所有对象实例起作用。

B: synchronized 是某实例的范围，synchronized isSync(){}防止多个线程中这一个实例同时访问这个类的synchronized 方法。

其实理解起来就是：
一个锁的是类对象，一个锁的是实例对象。
若类对象被lock，则类对象的所有同步方法全被lock；
若实例对象被lock，则该实例对象的所有同步方法全被lock。

5忘初心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized与static synchronized的区别
01-20
大家在学习java多线程的时候肯定会遇到这个...static synchronized这个是“全局锁”或者是“类锁”，该锁针对的是类，不管实例了多少个对象，线程都共享该锁。 下面我们来看代码： import java.util.concurrent.TimeUni
简单了解synchronized和lock的区别
08-25
主要介绍了简单了解synchronized和lock的区别,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
面试常考-synchronized与volatile
acc__essing的博客
11-01 234
JUC考察的就是原子性，可见性，有序性，如何从一个点展开探讨，最好的切入点其实就是synchronized以及volatile关键字，两者在JUC中扮演着很大一部分的重要角色。搞懂两者的机理很重要
面试官常问的synchronized关键字底层原理
程序员小章的博客
09-13 619
synchronized关键字底层原理 首先阅读这篇文章之前你需要知道： Java对象内存模型 JVM指令基础 文章目录synchronized关键字底层原理什么是并发问题？什么是synchronizedsynchronized的用法synchronized的原理监控工具分析JVM指令分析对象锁类锁synchronized优化总结 什么是并发问题？ 举个例子： 我们去银行取钱，我们卡里有500元，假如一个人是通过网银操作，另一个人是通过ATM操作，即模拟两个线程。网银准备取500，读取银行卡信息，这时余
面试常考：Java中synchronized和volatile有什么区别？
GitHub爱好者社区
10-27 263
点击上方“Github爱好者社区”，选择星标回复“资料”，获取小编整理的一份资料作者 l Hollis来源 l Hollis在我的博客和公众号中，发表过很多篇关于并发编程的文章，之前的文...
面试题精讲系列之锁-synchronized与Lock锁
liuerchong的博客
03-20 1704
锁分类 Java锁分类 分类标准 分类 根据线程是否需要对资源加锁 悲观锁/乐观锁 根据多个线程是否能获取同一把锁 共享锁/独享(独占、排他)锁 根据锁是否能够重复获取 可重入锁/不可重入锁 根据锁的公平性进行区分 公平锁/非公平锁 当多个线程并发访问资源时，当使用synchronized时 锁升级(偏向锁/轻量级锁/重量级锁) 根据资源被锁定后，线程是否阻塞 自旋锁/适应性自旋锁 悲观锁 VS 乐观锁 首先我们来看看悲观锁与乐观锁。 其实这里无论是悲观锁还是乐观锁，都
JAVA多线程面试中常问的问题
Keep learing, and stay fast
07-20 372
面试中常问的多线程问题
Synchronized 与 ReentrantLock 的区别
liuwg1226的专栏
09-07 6668
工作中我们经常会遇到 Java 常见的加锁方法，本文着重介绍最常见的 synchronized 与 ReentrantLock 的区别，以及说明在动态高并发时为什么推荐 ReentrantLock 而不是 Synchronized？ 一 Synchronized 与 ReentrantLock 的区别 1.1 底层实现的区别 底层实现上来说，synchronized 是 JVM 层面的锁，是 Java 关键字，通过 monitor 对象来完成（monitorenter 与 monitorexit），对象只有
【25】面试常问：谈谈 Java 中 synchronized 对象锁和类锁有什么区别？
Java烂猪皮
05-26 206
1、如果多线程同时访问同一类的 类锁（synchronized 修饰的静态方法）以及对象锁（synchronized 修饰的非静态方法）这两个方法执行是异步的，原因：类锁和对象锁是两种不同的锁。2、类锁对该类的所有对象都能起作用，而对象锁不能。
java面试常问知识点，快醒醒吧
EDGNB123的博客
04-13 182
前言 今天这篇文章是比较偏“教程”一点的文章。但也由浅入深，认真地分析了源码，并且介绍了一些在使用Spring Cache中常见的问题和解决方案，肯定是比简单的入门文档更有深度一些的，相信大家看了之后会有一定的收获。 01 JAVA基础 1.1 java知识点 Hashmap 源码级掌握，扩容，红黑树，最小树化容量，hash冲突解决，有些面试官会提出发自灵魂的审问，比如为什么是红黑树，别的树不可以吗；为什么8的时候树化，4不可以吗，等等 concureentHashMap，段锁，如何分段，和hashmap
进程、线程、协程 面试中的基础与关键 Synchronized与Reentranlock
chris3will的博客
04-22 239
Java中的进程、线程和协程都是并发编程的重要概念。进程是操作系统中的基本单位，每个进程都有自己独立的内存空间和系统资源，可以独立运行。Java中可以通过Runtime和ProcessBuilder等类创建和控制进程。线程是进程中的执行单元，可以共享进程的内存空间和系统资源。Java中的线程有这几种状态：新建（New）、可运行（Runnable）、阻塞（Blocking）、无限期等待（Waiting）、限期等待（Timed Waiting）和终止（Terminated）。
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
主要介绍了Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别，希望对大家有所帮助，一起跟随小编过来看看吧
Synchronized 和 Lock 的区别和使用场景
01-20
并发编程中，锁是经常需要用到的，今天我们一起来看下Java中的锁机制：synchronized和lock。 Synchronized 和 Lock的概念 Synchronized 是Java 并发编程中很重要的关键字，另外一个很重要的是 volatile。Syncronized...
Java关键字volatile和synchronized作用和区别
08-30
主要为大家详细介绍了Java关键字volatile和synchronized的作用和区别，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
国内移动端APP月活跃（MAU）Top5000 数据整理
06-16
国内移动端APP月活跃（MAU）Top5000 时间范围：2020年-2022年 具有一定参考价值 csv格式
和平巨魔跨进成免费.ipa
最新发布
06-16
和平巨魔跨进成免费.ipa
数据库管理工具:dbeaver-ce-23.0.4-macos-aarch64.dmg
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
【课件】8.4.1简单选择排序.pdf
06-16
【课件】8.4.1简单选择排序
static synchronized和synchronized的区别
10-11
static synchronized和synchronized是两种不同的关键字，用于实现线程同步。它们之间的区别如下： 1. synchronized关键字： - synchronized关键字用于修饰方法或代码块，用于实现对象级别的锁定。 - 当一个线程进入被synchronized修饰的方法或代码块时，它会获取该对象的锁定，并执行同步的代码。 - 在同一时间内，只有一个线程能够获取对象的锁定，其他线程需要等待锁定释放才能执行。 2. static synchronized关键字： - static synchronized关键字用于修饰静态方法或静态代码块，用于实现类级别的锁定。 - 当一个线程进入被static synchronized修饰的方法或代码块时，它会获取该类的锁定，并执行同步的代码。 - 与synchronized不同的是，static synchronized锁定的是类对象而不是实例对象，因此所有实例对象共享同一个锁定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值