Java中使用String作同步锁

2023-11-22 18:52•java•阅读 4566

在Java中String是一种特殊的类型存在，在jdk中String在创建后是共享常量池的，即使在jdk1.8之后实现有所不同，但是功能还是差不多的。

借助这个特点我们可以使用String来作同步的锁，比如更新用户信息的时候，可以使用用户的名称作为同步锁，这样不同的用户就可以使用不同的锁，提升并发性能。这个特点扩展开来适当的场景就非常之多了。

只不过正因为String的特殊性，java还包含了更多的与字符串相关的工具类，如StringBuffer、StringBuilder等。而且字符串映射的值是常量，但是String本身是可以new出来类似一个变量使用的。这些情况就会影响线程的同步了。

针对这些情况逐一测试一下。

使用new String()作一下测试

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class TestStringSync {
        private static Integer CNT = 0;
        
        public static void main(String[] args) {
                final String lock = new String(ObjectId.get().toString());
                run(lock);
        }

        private static void run(String lock) {
                final Integer threadNum = 10;
                final CyclicBarrier cb = new CyclicBarrier(threadNum, new Runnable() {
                        
                        public void run() {
                                System.out.println("threadNum : " + threadNum);
                        }
                });
                
                for(int i = 0; i< threadNum; i++) {
                        String tmpLock = new String(lock);
                        new TestThread(cb, tmpLock.toString()).start();
                }
        }

        static class TestThread extends Thread {
                private CyclicBarrier cbLock;
                private String lock;
                
                public TestThread(CyclicBarrier cbLock, String lock) {
                        this.cbLock = cbLock;
                        this.lock = lock;
                }
                public void run() {
                        try {
                                cbLock.await();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                                e.printStackTrace();
                        }
                        
                        try {
                                Thread.sleep(10);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                        
                        synchronized(lock) { //这里直接使用String对象本身作为锁
                                CNT = CNT+1;
                                System.out.println("Value:" + CNT);
                        }                       
                }
        }
        
}

输出的结果

threadNum : 10
Value:2
Value:2
Value:2
Value:2
Value:4
Value:5
Value:5
Value:4
Value:4
Value:4

从结果可以看出，每个线程创建前使用new String(lock)会产生不同的锁，造成线程同步失败。所以在使用的时候要特别注意这点，new String(lock)是会产生不同的对象，他们所指向的对象锁是不同的。

StringBulider和StringBuffer的问题

由上引申到StringBuilder和StringBuffer，这也是使用字符串作为同步锁需要注意的问题。比如某些场景下需要对字符串拼接后作为锁。比如：用户名+机构名:

StringBuilder tmpLock = new StringBuilder();
tmpLock.append("user name");
tmpLock.append("org name");
for(int i = 0; i< threadNum; i++) {
        new TestThread(cb, tmpLock.toString()).start();
}

运行结果

threadNum : 10
Value:2
Value:2
Value:2
Value:3
Value:2
Value:3
Value:2
Value:3
Value:2
Value:2

可见，这个锁还是不行。原因是StringBuiler的toString方法中返回的是new String，代码如下：

   @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

这就导致线程拿到的还是不同的字符串对象。

解决方法

针对上面举的例子可以发现，使用String作为同步锁必须注意产生不同对象的问题，必须保证线程拿到的是同一个String对象。做法最简单的就是使用同一个String对象，但这个有时很难保证。特别是我们很多的时候代码是分布式环境下的。

比如，我们将用户名存在了redis里，线程每次同步的时候去redis里取一下数据，这样就很有可能导致产生新的String对象。这个时候就得使用intern()方法。上面的代码修改为：

synchronized(lock.intern()) {
        CNT = CNT+1;
        System.out.println("Value:" + CNT);
}

这样就是直接获取的是字符串的值本身，而不是取的String的对象，以此保证同一个字符串拿到的是同一个String对象，自然在同一个进程中就是同一个对象锁了。

测试结果

threadNum : 10
Value:1
Value:2
Value:3
Value:4
Value:5
Value:6
Value:7
Value:8
Value:9
Value:10

在Java中String是一种特殊的类型存在，在jdk中String在创建后是共享常量池的，即使在jdk1.8之后实现有所不同，但是功能还是差不多的。

针对这些情况逐一测试一下。

使用new String()作一下测试

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class TestStringSync {
        private static Integer CNT = 0;
        
        public static void main(String[] args) {
                final String lock = new String(ObjectId.get().toString());
                run(lock);
        }

        private static void run(String lock) {
                final Integer threadNum = 10;
                final CyclicBarrier cb = new CyclicBarrier(threadNum, new Runnable() {
                        
                        public void run() {
                                System.out.println("threadNum : " + threadNum);
                        }
                });
                
                for(int i = 0; i< threadNum; i++) {
                        String tmpLock = new String(lock);
                        new TestThread(cb, tmpLock.toString()).start();
                }
        }

        static class TestThread extends Thread {
                private CyclicBarrier cbLock;
                private String lock;
                
                public TestThread(CyclicBarrier cbLock, String lock) {
                        this.cbLock = cbLock;
                        this.lock = lock;
                }
                public void run() {
                        try {
                                cbLock.await();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                                e.printStackTrace();
                        }
                        
                        try {
                                Thread.sleep(10);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                        
                        synchronized(lock) { //这里直接使用String对象本身作为锁
                                CNT = CNT+1;
                                System.out.println("Value:" + CNT);
                        }                       
                }
        }
        
}

输出的结果

threadNum : 10
Value:2
Value:2
Value:2
Value:2
Value:4
Value:5
Value:5
Value:4
Value:4
Value:4

StringBulider和StringBuffer的问题

由上引申到StringBuilder和StringBuffer，这也是使用字符串作为同步锁需要注意的问题。比如某些场景下需要对字符串拼接后作为锁。比如：用户名+机构名:

StringBuilder tmpLock = new StringBuilder();
tmpLock.append("user name");
tmpLock.append("org name");
for(int i = 0; i< threadNum; i++) {
        new TestThread(cb, tmpLock.toString()).start();
}

运行结果

threadNum : 10
Value:2
Value:2
Value:2
Value:3
Value:2
Value:3
Value:2
Value:3
Value:2
Value:2

可见，这个锁还是不行。原因是StringBuiler的toString方法中返回的是new String，代码如下：

   @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

这就导致线程拿到的还是不同的字符串对象。

解决方法

synchronized(lock.intern()) {
        CNT = CNT+1;
        System.out.println("Value:" + CNT);
}

测试结果

threadNum : 10
Value:1
Value:2
Value:3
Value:4
Value:5
Value:6
Value:7
Value:8
Value:9
Value:10

Java中使用String作同步锁

使用new String()作一下测试

StringBulider和StringBuffer的问题

解决方法

使用new String()作一下测试

StringBulider和StringBuffer的问题

解决方法

相关推荐

Java关键词synchronized解读

Linux内核源码分析 -- 同步原语 -- 互斥锁 mutex，未完成

Intellij idea 中修改java web代码 ，网页不同步

浅析Java关键词synchronized的使用

java同一个类不同方法间的同步

Java使用CountDownLatch实现网络同步请求的示例代码

linux同步机制2

java中String a ; String a = null 和String a = ""的区别

Intellij idea 中修改java web代码，网页不同步