小编Tem*_*ing的帖子

示例代码:

class Sample{
    private int v;
    public void setV(){
        Lock a=new Lock();
        a.lock();
        try{
            v=1;
        }finally{
            a.unlock();
        }
    }
    public int getV(){
        return v;
    }
}

如果我有一个线程不断调用getV而我只是在另一个线程中执行setV一次,那么读取线程是否保证在写入后立即看到新值？或者我需要使"V"易失或AtomicReference？

如果答案是否定的,那么我应该将其更改为:

class Sample{
    private int v;
    private Lock a=new Lock();
    public void setV(){
        a.lock();
        try{
            v=1;
        }finally{
            a.unlock();
        }
    }
    public int getV(){
        a.lock();
        try{
            int r=v;
        }finally{
            a.unlock();
        }
        return r;
    }
}

标题为.我想知道我的查询是否得到了很好的优化.

我试图在Package-Explorer的项目上下文菜单中添加一个子菜单。但是，我找不到该菜单的菜单ID。

所以我的问题是如何在Eclipse中查找menuid？

非常感谢您的帮助。

这段代码来自于java并发实践，我实在是看不懂。

@ThreadSafe
public class BoundedBuffer<V> extends BaseBoundedBuffer<V> {
    // CONDITION PREDICATE: not-full (!isFull())
    // CONDITION PREDICATE: not-empty (!isEmpty())

    public BoundedBuffer(int size) { super(size); }

    // BLOCKS-UNTIL: not-full
    public  synchronized  void put(V v) throws InterruptedException {
        while (isFull())
            wait();
        doPut(v);
        notifyAll();
    }

    // BLOCKS-UNTIL: not-empty
    public  dsynchronize  V take() throws InterruptedException {
        while (isEmpty())
            wait();
        V v = doTake();
        notifyAll();
        return v;
    }
}

put 和 take 方法是同步的。如果某个线程在 put 方法中等待，则没有人可以进入 take 或 put 方法，因此，在大多数情况下，如果一个线程开始等待，它将永远等待。

我是不是理解错了什么？

我经历了一个非常痛苦的java学习曲线,仍然是一个新手.

我正在设计一个低级库类,将来它可能可以在多线程环境中使用,也可以只在一个线程中使用.我不知道.

我可以让这个类的用户从外面同步.但这比提供线程安全版本效率低得多.

这是p代码.

Class Example{
    public int checkAndProcess(){
        WriteLock writeLock=this.getWriteLock();
        ReadLock readLock=new ReadLock(writeLock);
        int a;
        try{
            lockManager.lock(readLock);
            a=readSomething();
        }finally{
            lockManager.release(readLock);
        }
        if(a!=null){
            return a;
        }
        try{
            lockManager.lock(writeLock);
            a=doSomeProcessing();
        }finally{
            lockManager.release(writeLock);
        }
        return a;
    }
}

它比从外部同步要快得多,因为readlock不会阻塞.它是在每个方法调用中创建和垃圾收集的.

问题:

开销.WriteLock非常复杂,ReadLock既便宜又简单,但它是在每个方法调用中创建的(可能是多个),所以仍然是开销.

我应该为每个这样的类提供线程安全版吗？每个开源库都不会这样做.但是如果我不提供它,让用户从外部同步,性能将会降低.

还是有更好的方法吗？

编辑:

我应该分开吗？

将其拆分为无状态处理器和商店,让用户创建readLock/writeLock来锁定？如果我这样做,商店将完全为处理器设计,对其他类没有太大意义,图书馆将很快被这些​​东西所激发.

这是我的真实代码.如果你不喜欢,你可以忽略它.

package lazycatTools.runtime;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.jobs.Job;
import org.osgi.framework.AllServiceListener;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;

public class DynamicServiceTracker {

    private final …