Java：基于对象值的同步

Question

我想基于输入参数同步一个方法或一个块。

因此，我有一个API，它在post有效负载中有两个长类型的输入（比如id1和id2)，可以是原始的，也可以是包装的），可以是JSON。这个API将被多个线程同时或随机地在不同时间调用。

现在如果第一个API调用有ID1=1和ID2=1，同时另一个API调用有ID1=1和ID2=1，它应该等待第一个API调用处理完毕后再执行第二个调用。如果第二个API调用具有不同的值组合，如ID1=1和ID2=2，则它应该在没有任何等待时间的情况下并行执行。

我不介意创建一个API资源方法也可以调用的服务方法，而不是直接在API资源方法上处理。

我使用的是spring boot Rest控制器API。

public static void main(String[] args) throws Exception {
    ApplicationContext context = SpringApplication.run(Application.class, args);
    AccountResource ar = context.getBean(AccountResource.class);
    UID uid1 = new UID();
    uid1.setFieldId(1);
    uid1.setLetterFieldId(1);
    UID uid2 = new UID();
    uid2.setFieldId(2);
    uid2.setLetterFieldId(2);
    UID uid3 = new UID();
    uid3.setFieldId(1);
    uid3.setLetterFieldId(1);
    Runnable r1 = new Runnable() {

        @Override
        public void run() {
            while (true) {
                ar.test(uid1);
            }

        }
    };
    Runnable r2 = new Runnable() {

        @Override
        public void run() {
            while (true) {
                ar.test(uid2);
            }

        }
    };
    Runnable r3 = new Runnable() {

        @Override
        public void run() {
            while (true) {
                ar.test(uid3);
            }

        }
    };
    Thread t1 = new Thread(r1);
    t1.start();
    Thread t2 = new Thread(r2);
    t2.start();
    Thread t3 = new Thread(r3);
    t3.start();

}
@Path("v1/account")
@Service
public class AccountResource {
public void test(UID uid) {
        uidFieldValidator.setUid(uid);
        Object lock;
        synchronized (map) {
            lock = map.get(uid);
            if (lock == null) {
                map.put(uid, (lock = new Object()));
            }
            synchronized (lock) {
                //some operation
            }
        }
    }
}

package com.urman.hibernate.test;

import java.util.Objects;

public class UID {
    
    private long letterFieldId;
    private long fieldId;
    private String value;
    public long getLetterFieldId() {
        return letterFieldId;
    }
    public void setLetterFieldId(long letterFieldId) {
        this.letterFieldId = letterFieldId;
    }
    public long getFieldId() {
        return fieldId;
    }
    public void setFieldId(long fieldId) {
        this.fieldId = fieldId;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    @Override
    public int hashCode() {
        return Objects.hash(fieldId, letterFieldId);
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        UID other = (UID) obj;
        return fieldId == other.fieldId && letterFieldId == other.letterFieldId;
    }
}

Answer 1

您需要一个锁的集合，您可以将其保存在一个映射中，并根据需要进行分配。这里我假设您的id1和id2是字符串；适当调整。

 Map<String,Object> lockMap = new HashMap<>();
   :

 void someMethod(String id1, String id2) {
     Object lock;
     synchronized (lockMap) {
         lock = lockMap.get(id1+id2);
         if (lock == null) lockMap.put(id1+id2, (lock = new Object()));
     }
     synchronized (lock) {
         :
     }
 }

您需要对映射操作进行一点“全局”同步，或者可以使用一个并发实现。为了实现的简单性，我使用了基HashMap。

选择锁后，对其进行同步。