JAVA中synchronized和String引出的一系列内容

最新推荐文章于 2024-06-07 14:21:16 发布
最新推荐文章于 2024-06-07 14:21:16 发布
阅读量4.7k 收藏 6
点赞数 5
分类专栏： Java杂七杂八 文章标签： JAVA string synchronized hashcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014653197/article/details/76177277
版权

背景

最近，在开发一个功能，由于会存在并发问题（发生几率不大），因此想上个锁避免一下，但是又因为处于性能考虑，不想锁整个方法或者都去锁住同一个对象，这样会使得所有请求进入这个方法后，都会变成串行进行排队，但是很多时候，不同的请求之间是没有资源竞争的，应该是可以并行的，对于有竞争的请求，才应该采取串行的方式。该方法只有一个String类型的入参，于是我一开始就打算用这个入参作为被锁的对象，因为一开始简单的想着，string类型的都是在常量池中的，返回的都是同一个对象，理论上可以做到入参为一样的字符串时，串行执行，不一样的字符串时，并行执行。但是谨慎起见，在自己写了几个相关测试后，发现背后内容挺多的。


测试一：

测试结果：符合预期。一样的字符串，执行变为串行。不一样的字符串，执行仍然是并行。

测试代码：

public class Test {

	public static void main(String... args) throws Exception {
		new Thread() {
			public void run() {
				try {
					remoteCall("102017071807514199868487451");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();

		new Thread() {
			public void run() {
				try {
					remoteCall("102017071807514199868487451");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();

		new Thread() {
			public void run() {
				try {
					remoteCall("1111111111111111111111111111");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();

	}

	private static void remoteCall(String aaa) throws InterruptedException {
		System.out.println("进入方法：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());

		synchronized (aaa) {
			System.out.println("进入锁内：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
			Thread.sleep(5000);
		}
		System.out.println("退出锁：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
	}

}
输出结果： 

进入方法：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501125434326
进入锁内：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501125434326
进入方法：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501125434327
进入方法：Thread-2数据为：1111111111111111111111111111 hashcode：-872251968 执行时间：1501125434328
进入锁内：Thread-2数据为：1111111111111111111111111111 hashcode：-872251968 执行时间：1501125434328
退出锁：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501125439327
进入锁内：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501125439327
退出锁：Thread-2数据为：1111111111111111111111111111 hashcode：-872251968 执行时间：1501125439329
退出锁：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501125444327

从输出结果来看，我们的目的好像是达到了。但是如果我们对String类型有一定了解的话，其实就会发现上面的方法有一个很大的漏洞，那就是我们的字符串并不是动态传入的。所谓的不是动态传入的意思就是，我们要传入方法的字符串，其实在程序编译期间就已经知道了。问题就出在了这里：

在程序编译期，编译程序先去字符串常量池检查，是否存在“102017071807514199868487451”，如果不存在，则在常量池中开辟一个内存空间存放“102017071807514199868487451”；如果存在的话，则不用重新开辟空间。然后在栈中开辟一块空间，命名为变量名，存放的值为常量池中“102017071807514199868487451”的内存地址。

因此，上面的两个字符串“102017071807514199868487451”是同一个对象，因此锁就生效了。但是可惜的是，我的程序关于这个入参的字符串内容，很多时候都是动态生成的，也就是编译期间是不知道的，于是就有了下面的测试二。

测试二：

测试结果：不符合预期。一样内容的字符串都是并行了。

测试代码：

public class Test {

	public static void main(String... args) throws Exception {
		new Thread() {
			public void run() {
				try {
					remoteCall("102017071807514199868487451");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();

		new Thread() {
			public void run() {
				try {
					Scanner scanner = new Scanner(System.in);
					remoteCall(scanner.nextLine());
					scanner.close();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();
	}

	private static void remoteCall(String aaa) throws InterruptedException {
		System.out.println("进入方法：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
		synchronized (aaa) {
			System.out.println("进入锁内：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
			Thread.sleep(5000);
		}
		System.out.println("退出锁：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
	}

}
输出结果： 
进入方法：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126502734
进入锁内：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126502734
102017071807514199868487451
进入方法：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126503698
进入锁内：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126503698
退出锁：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126507735
退出锁：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126508699
从输出结果可以明显看出，我在控制台中再一次输入102017071807514199868487451后，发现它立刻就获得锁了。虽然hashcode和字符串内容都一样，但是从它立马获得锁我们就可以明显看出，两个102017071807514199868487451字符串并不是同一个对象。

要知道hashcode虽然相同，但是因为这个是一个可以复写的方法，所以因此对于String的hashcode而言，它是不具有唯一性的，这一点我们从可以从String的源码中看出：

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }
又因为，当我们使用Scanner通过System.in从控制台读取用户的输入时，其实是产生了一个新的对象，这一点也可以轻松从Scanner的源码中看出： 
 public String nextLine() {
        if (hasNextPattern == linePattern())
            return getCachedResult();
        clearCaches();

        String result = findWithinHorizon(linePattern, 0);
        if (result == null)
            throw new NoSuchElementException("No line found");
        MatchResult mr = this.match();
        String lineSep = mr.group(1);
        if (lineSep != null)
            result = result.substring(0, result.length() - lineSep.length());
        if (result == null)
            throw new NoSuchElementException();
        else
            return result;
    }
其实，我们可以修改一下remoteCall方法，再测试一次，就非常明白了： 

private static void remoteCall(String aaa) throws InterruptedException {
		System.out.println("真正的内存地址：" + System.identityHashCode(aaa));
		System.out.println("进入方法：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
		synchronized (aaa) {
			System.out.println("进入锁内：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
			Thread.sleep(5000);
		}
		System.out.println("退出锁：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
	}
此时的输出为： 
真正的内存地址：1616247035
进入方法：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126946265
进入锁内：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126946266
102017071807514199868487451
真正的内存地址：455326124
进入方法：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126947367
进入锁内：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126947367
退出锁：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126951266
退出锁：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501126952367
可以明显的看出，其实两者的内存地址是不一样的，是明显的两个不同的对象。

那对于这种情况，有没有方法解决呢？能不能做到字符串内容的时候，就串行执行，内容不一样的时候就并行执行呢？答案是有的，就是利用String的intern（）方法。

测试三：

测试结果：符合预期。一样的字符串，执行变为串行。不一样的字符串，执行仍然是并行。

测试代码：

public class Test {

	public static void main(String... args) throws Exception {
		new Thread() {
			public void run() {
				try {
					remoteCall("102017071807514199868487451");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();

		new Thread() {
			public void run() {
				try {
					Scanner scanner = new Scanner(System.in);
					remoteCall(scanner.nextLine());
					scanner.close();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		}.start();
	}

	private static void remoteCall(String aaa) throws InterruptedException {
		System.out.println("真正的内存地址：" + System.identityHashCode(aaa));
		aaa = aaa.intern();
		System.out.println("真正的内存地址：" + System.identityHashCode(aaa));
		System.out.println("进入方法：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
		synchronized (aaa) {
			System.out.println("进入锁内：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
			Thread.sleep(5000);
		}
		System.out.println("退出锁：" + Thread.currentThread().getName() + "数据为：" + aaa + " hashcode：" + aaa.hashCode() + " 执行时间：" + System.currentTimeMillis());
	}

}

输出结果： 

真正的内存地址：1616247035
真正的内存地址：1616247035
进入方法：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501127094470
进入锁内：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501127094470
102017071807514199868487451
真正的内存地址：1917485542
真正的内存地址：1616247035
进入方法：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501127095710
进入锁内：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501127099471
退出锁：Thread-0数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501127099471
退出锁：Thread-1数据为：102017071807514199868487451 hashcode：618974246 执行时间：1501127104471

看着输出应该就一目了然了，这里就不多加解释了。

需要注意的是，intern可以使得内容一样的字符串，指向同一个内存地址，这会使得大量字符串难以清理，导致内存上升。因此我们，使用这种方法的时候，还要对入参的字符串的取值范围进行一定估量。如果经常调用这个方法的时候，传入的参数都是不一样，并且变化很大的字符串，可能就需要小心使用了。在我实际的工作环境中，调用这个方法时，传入的字符串都是在一定的范围内的，并且总体个数我可以接受，因此我不必考虑这个内存消耗的问题。因此，我可以做到牺牲一部分内存和一部分方法的执行效率，以此来提高整个方法执行的并行度。

岁月如歌似梦
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java给字符串加锁_Java中String做为synchronized同步锁
weixin_28950543的博客
02-27 1885
synchronized (("" +userId).intern()) {//TODO:something}JVM内存区域里面有一块常量池，关于常量池的分配：JDK6的版本，常量池在持久代PermGen中分配JDK7的版本，常量池在堆Heap中分配字符串是存储在常量池中的，有两种类型的字符串数据会存储在常量池中：编译期就可以确定的字符串，即使用""引起来的字符串，比如String a = "12...
Java中String做为synchronized同步锁使用详解
weixin_45623983的博客
11-24 1364
Java中String做为synchronized同步锁使用详解
字符串为什么不建议作为synchronized的锁对象
最新发布
weixin_45500957的博客
06-07 1034
使用特定的锁对象而不是字符串进行同步是推荐的最佳实践。这种方式避免了字符串常量池带来的潜在问题，确保锁的唯一性和同步操作的安全性。在多线程环境中，这样的做法可以避免意外的锁共享，提高程序的稳定性和可维护性。字符串常量池是 JVM 用于优化内存和提高性能的一种机制，通过共享相同内容的字符串对象来减少内存开销。由于字符串常量池的存在，直接使用字符串字面量作为锁对象可能导致意外的锁共享。因此，在需要细粒度控制的场景中，推荐使用独立的锁对象来实现同步。
synchronized(string)
yzx3105的博客
11-02 1970
String是Java中的一种特殊类型，String在创建后存入字符串常量池。利用这个特征，可以使用String作为同步锁。例如，在更新用户信息时，可以使用用户的名称作为同步锁，不同的用户可以使用不同的锁来提高并发性能。这个特征扩展适当的场景非常多。
Java中String做为synchronized同步锁该怎么办
qq_40367673的博客
02-13 928
String做为synchronized同步锁
深入理解Java并发4——synchronized关键字
xiaowang627的博客
03-07 1331
一 概述   由博客（http://blog.csdn.net/xiaowang627/article/details/60584428），我们已经体验到synchronized关键字的强大之处，该关键字是Java中解决并发问题最常用的方法，也是最简单的方法，该关键字有三种用法： （1）修饰普通方法。 （2）修饰静态方法。 （3）修饰代码块。 二 修饰代码块   2.1 先看...
Java synchronized锁 String 和 Integer 会有什么问题?
张伯毅的专栏
06-21 1005
java synchronized 锁String , Integer 对象...
Java中synchronized锁字符串
jim8973的博客
10-16 3967
Synchronized锁字符串代码如下 public class StringThread implements Runnable{ private static final String LOCK_PREFIX = "XXX---"; private String taskNo; public StringThread(String taskNo) { this.taskNo = taskNo; } @Override public
Synchronized block 为String 时的情况
Lucy_Leezhi
02-19 640
Java synchronized
Java关键字——synchronized
weixin_42547014的博客
07-21 2889
什么是synchronize 如何使用 底层原理 做过那些优化 对象在内存中 用户态？内核态？ 为什么效率低 一、认识 Synchronized synchornized 是 Java 中的一个关键字，解决的是多个线程之间访问资源的同步性，synchronized 关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 重量级锁：其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线.
使用synchronized锁String的问题
karrbo的博客
10-11 1304
使用场景 在导出文件时候，我们规定同一用户只能同时导出一份数据。此时我们选择使用"USER"+userName来作为锁。 代码如下： String key = "USER" + user.getName(); synchronized (key) { //todo } 其中"USER" + user.getName()会优化成StringBuilder，然后调用StringBuilder的toString方法，我们可以看到，这个时候实际上创建了一
为何JVM中不建议使用synchronized（String s）?实例详解+解决方法
qq_28295947的博客
01-19 3818
阿泽在学习synchronized关键字小结 首先呢总结一下synchronized的三种使用方式： 修饰实例⽅法，给对象实例加锁 synchronized void method(){ } 修饰静态⽅法，给当前类加锁 synchronized static void method(){ } 修饰代码块，给当前对象/类加锁 synchronized（this）{ } 重点在于第三点，很多知识博客中都提醒了这样一点 尽量不要使⽤ synchronized(String a) 因为 JVM
synchronized
发财猪猪的笔记窝
02-24 392
目录同步概念对象对象头Mark Word线程中的Lock RecordMonitorsynchronized 关键字的底层原理synchronized 同步语句块synchronized 修饰方法的的情况锁优化自旋锁自适应自选锁锁消除锁粗化锁升级综述无锁偏向锁轻量级锁重量级锁为什么升级为轻量级锁时要把对象头里的Mark Word复制到线程栈的锁记录中呢锁的优劣偏向锁轻量级锁重量级锁synchronized关键字最主要的三种使用方式一个对象在两个线程中分别调用一个同步静态方法和一个同步实例方法，是否会互斥尽量
UUID生成
fishinhouse的专栏
09-04 1822
1、随机生成UUID  public static synchronized String getUUID(){ UUID uuid=UUID.randomUUID(); String str = uuid.toString(); String uuidStr=str.replace("-",""); return uuidStr; } 2、根据字...
SnowFlake分布式唯一ID 生成器
diyujun6099的博客
08-01 1465
Snowflake生成IDtwitter开发的一套全局唯一ID生成算法，要点如下：41位的时间序列(精确到毫秒，41位的长度可以使用69年) 10位的机器标识(10位的长度最多支持部署1024个节点) 12位的计数顺序号(12位的计数顺序号支持每个节点每毫秒产生4096个ID序号) 最高位是符号位，始终为0。简单可靠，性能好，趋势有序，不引入第三方系统。缺点是有使用时间限制，8-100年...
聊聊Java关键字synchronized
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-13 4121
具体例子，某段线程得到锁Test.class之后，执行临界代码逻辑，可能会先执行变量b初始化的逻辑，在执行a变量初始化的逻辑，但是最终结果都会执行a+b的逻辑。每个线程使用synchronized获得锁操作临界资源时，首先需要获取临界资源的值，为了保证临界资源的值是最新的，JMM模型规定线程必须将本地工作内存清空，到共享内存中加载最新的进行操作。正是由于锁互斥的失败，导致两个线程同时到临界区域加载资源，获得的count都是0，经过自增后都是1，导致数据少了1。
浅析Java中synchronized与static synchronized
C18298182575的博客
11-25 578
synchronized VS static synchronized
Java-synchronized的使用方法
LeLe_Feb
07-14 466
最近在看《Java 多线程编程核心技术》，顺便花点时间总结下synchronized的用法。在介绍之前需要了解到“非线程安全”问题存在于“实例变量”中，如果是方法内部的变量，则不存在“非线程安全”问题。下面举个栗子：方法内部声明一个变量时，是不存在“非线程安全”问题的。/** * Created by LZF on 2017/7/13. * 测试：方法内部的变量，不存在“非线程安全”问题 */
java 中 synchronized 和 reentrantlock 怎么选
05-15
在Java中，synchronized和ReentrantLock都是用来实现线程同步的机制。但是它们之间有一些区别，你可以根据自己的需求来选择其中一个。 synchronized是Java中最基本的同步机制，它可以用来实现对代码块或方法的同步...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值