Java 锁定静态对象

一次运行多个类A实例

类A在其运行中调用类B的多个实例

public Class Main {

    public static void main(String args[] ) {

        A a1 = new A();
        Thread t1 = new Thread(a1);
        t1.start();

        A a2 = new A();
        Thread t2 = new Thread(a2);
        t2.start();
    }
}

Class A implements Runnable {

    public void run() {

        B b1 = new B();
        Thread t11 = new Thread(b1);
        t11.start();

        B b2 = new B();
        Thread t21 = new Thread(b2);
        t21.start();
    }
}

在类B中有一个名为“method”的方法，在该方法中编辑集合。该编辑是基于类B中的静态锁完成的

编辑-

B类实现可运行{
私有最终静态对象锁=新对象（）；
私有最终静态集busyRecords=newhashset（）；
公共无效等待工作（最终目标）{
已同步（锁定）{
while（busyRecords.contains（obj））{
LOCK.wait（）；//去睡觉
}
busyRecords.add（obj）；
}
}
公共无效doneWith（最终目标）{
已同步（锁定）{
busyRecords.remove（obj）；
LOCK.notifyAll（）；
}
}
公共无效法（obj）{
试一试{
waitToWorkOn（obj）；
…用obj做一些工作
}
最后{
doneWith（obj）；
}
}
公开募捐{
方法（getObj（））
}
}

但是当从不同的“A”实例访问该集合时，它不需要并发控制。仅在A实例中，需要为所有B实例锁定它

我的意思是，当A的两个实例正在运行时，不应该让它们等待。但在A实例中，如果两个B对象拾取相同的对象，它们必须在锁内等待。等待。

---

我认为锁不能成为非静态的，因为A调用了B的多个实例。我们可以在这里调优LOCK对象，以便在A对象之间实现更好的并发性。

您可以创建共享集合的线程安全实例，并将其传递给给定A的所有B

Class A implements Runnable {

    public void run() {

        // create shared set instance scoped to A, and make it thread-safe
        Set col = Collections.synchronizedSet(new HashSet());

        B b1 = new B(col);
        Thread t11 = new Thread(b1);
        t11.start();

        B b2 = new B(col);
        Thread t21 = new Thread(b2);
        t21.start();
    }
}

Class B implements Runnable {

    private final Set<T> someSet;

    private B(Set<T> someSet) {
      this.someSet = someSet;
    }

    public void method(final T obj) {
        someSet.add(obj);
    }

    public void run() {
        method()
    }
}

A类实现可运行{
公开募捐{
//创建作用域为的共享集实例，并使其线程安全
Set col=Collections.synchronizedSet（新HashSet（））；
B b1=新的B（col）；
螺纹t11=新螺纹（b1）；
t11.start（）；
b2=新的B（col）；
螺纹t21=新螺纹（b2）；
t21.start（）；
}
}
类实现可运行的{
私有最终集；
二等兵B（集合）{
this.someSet=someSet；
}
公共作废法（最终目标）{
someSet.add（obj）；
}
公开募捐{
方法（）
}
}

那么问题是什么呢？

在C类中有一个名为“method”的方法，其中编辑了一个集合。该编辑是基于类C中的静态锁完成的。

。。在代码中C类定义在哪里？将LOCK和someSet移动到一个实例成员？现在LOCK对象锁定t1和t2，因为它是静态的。我只需要在课堂上锁定t1MAin@Vishal-更正我只想运行两个A实例而不互相阻塞。在..中仍然需要并发性。。顺便说一句，这个设置只是我跟踪繁忙记录的一种方式，我的代码中有一个免费的等待和通知，不允许两个线程同时在同一个对象上工作。我可以只将我的锁对象移动到a->run（）中，并将该对象传递给B吗。在B中，我有一组集合用于控制插入到许多表中的a。。通过这种方式，我继续使用我的代码，只有LOCK对象不是静态对象，而是一个作用域为a的对象objct@fortm-当然，也可以（基本上与我的解决方案相同，只是不同的锁实例）。更好的方法是将这个共享的B状态封装到一个新类中，并同步它的方法。

Class A implements Runnable {

    public void run() {

        // create shared set instance scoped to A, and make it thread-safe
        Set col = Collections.synchronizedSet(new HashSet());

        B b1 = new B(col);
        Thread t11 = new Thread(b1);
        t11.start();

        B b2 = new B(col);
        Thread t21 = new Thread(b2);
        t21.start();
    }
}

Class B implements Runnable {

    private final Set<T> someSet;

    private B(Set<T> someSet) {
      this.someSet = someSet;
    }

    public void method(final T obj) {
        someSet.add(obj);
    }

    public void run() {
        method()
    }
}