标签: synchronization

让我们说我有一个简单的地图,经常被查询,但只是偶尔修改.目前我正在使用synchronized块来防止在添加到地图时遇到竞争条件(简化示例):

public class MyRepository {

    private static HashMap<Integer, Object> MAP = new HashMap<Integer, Object>();

    public static Object getInstance(Integer key) {
        synchronized (MAP) {
            return MAP.get(key);
        }
    }

    public static void addInstance(Integer key, Object instance) {
        synchronized (MAP) {
            MAP.put(key, instance);
        }
    }

}

我遗漏了任何应用程序特定的废话,如处理关键冲突等.你得到的图片,非常简单.在运行时,映射在应用程序启动时填充实例.之后,地图很少被修改(一旦在蓝色的月亮,所以说).另一方面,经常查询地图,查询地图的多个线程相互阻塞.

是否有一种保护机制允许多个"读者"同时掌握地图,同时仍然只有一个"作家"？

我有一个同步的函数,但似乎我无法直接更改该块中的实例变量的值.

+(id)allocWithZone:(NSZone *)zone
{
@synchronized(self) {
    if (sharedInstance == nil) {
        sharedInstance = [super allocWithZone:zone];

        //This is not allowed
        something = @"hello";

        //This is allowed
        self.something = @"hello world!";

        return sharedInstance;
    }
}

return nil;
}

为什么会这样？我有一个我需要直接访问的变量(我不想合成该变量).我该如何解决这个问题？

如果正在运行的线程访问特定对象,那么它还会锁定该特定对象的字段成员？

在游戏中我们的互联网组装团队正在编程,我们假设我们的观众中的每个人都将在游戏中获得全速.

因此,为了节省视频RAM,并希望为显卡提供更多的空闲时间,使用没有双缓冲的V-sync将是我们的最佳选择.因此,在OpenGL中,我们需要知道如何做到这一点.

根据我的理解,V-sync是指图形卡在完成渲染单帧后暂停,直到该帧完成发送到显示设备.双缓冲不会暂停渲染操作(或者可能是暂停渲染操作,或者可能是特定于实现;不确定),因为它会在复制到帧缓冲区之前绘制到第二个缓冲区,以便监视器获得完整帧或不根本就是新帧(具体来说,是帧缓冲区中最后存储的图像).好吧,我们不需要这个功能,只要显卡只是在它需要时才写入帧缓冲区.

这是一个非常慢的在线游戏(但它非常有创意^ _ ^).实时行动非常少.因此,非常精确的用户输入不是必需的; 它可以在渲染帧之前随时从OS捕获为单个单元.

所以,为了做到这一点,我需要能够从OpenGL获得"Frame已经完成发送到监视器"的消息.可能吗？如果没有,最好的选择是什么？

该游戏目前仅针对Windows编程,但应该在几个月内完成Linux的工作.

我有一个奇怪的同步架构,我正在寻找一个优雅的解决方案.我已经有了一个解决方案,但我不能说它的有效性,也有点难看.所以这是问题,希望有人可以帮助我.

有两组任务可以启动和运行.每个任务都有自己的线程.这两个组都从一个负责同步部分的超类扩展.为简单起见,我将这两个组称为A组和B组.

条件:

• 如果只有B组任务在运行,那么它们可以同时运行,并且它们不会相互干扰.

• 如果启动了组A任务*,则组B任务的构造函数应该失败并出现异常.即使A组任务已在运行,也可以创建任意数量的A组任务

• 在所有当前的B组任务完成之前,A组任务无法执行.(*从上面)

• 一次只能运行1个A组任务.他们必须排队.(只要先前的条件仍然适用,可以选择在运行两个A组任务之间阻止B组任务)

我相信我的方法有效但我不喜欢它的工作方式,因为它使用了许多不同的同步点,以及我在等待计数器时有一个睡眠的事实.无论如何,代码如下

public abstract class LockableTask<Params> extends AsyncTask {

private final boolean groupA;
private static Boolean locked = false;
private static final Semaphore semLock = new Semaphore(1);
private static int count = 0;

public LockableTask(boolean groupA) {
    this.groupA = groupA;
    synchronized (locked) {
        if (locked && !groupA) {
            throw new InputException("We are locked, please wait");
        }
    }
}

@Override
protected final AsyncReturn doInBackground(Params... params) {
    if (!groupA) {
        synchronized (locked) {
            count++;
        }
    } …

我在某处读到x86处理器具有高速缓存一致性,并且可以在每次写入时同步多个内核的字段值.

这是否意味着如果我们计划仅在x86处理器上运行,我们可以在不使用java中的'volatile'keywoard的情况下进行编码？

更新:

好吧,假设我们忽略了指令重新排序的问题,我们是否可以假设在x86处理器上不存在对核心不可见的非易失性字段的分配问题？

我有一个父进程,分叉两个孩子.我需要在这些子进程运行时强制执行某个命令.

例如,父进程从文件中获取"命令",并且根据该命令,父进程将使用未命名的管道将该命令传递给子a或子b.我需要在子节点中发生的事情与父节点从文件中接收命令的顺序相同.

我使用信号量的方式在进程之间不起作用.有任何想法吗？

我有一个课程如下

public MyClass{

Boolean flag = false;

    public Boolean getflag(){
       synchronized(flag){
          //BLOCK 1
          return flag;
       }
    }

    public Boolean setflag(){
       synchronized(flag){
           //BLOCK 2
           this.flag = flag;
       }
    }
}

两种方法都在对象标志上同步.现在我怀疑是两个不同的线程可以同时执行同步块(1和2).可能出现以下情况吗？1)线程1是设置标志值,线程2是否同时获取其值？

我刚刚将trac从0.11更新为0.12,因为多存储库浏览.在svn同步自动工作之前,但是现在我必须进入管理面板并输入repository resync *命令,有没有办法自动执行此操作？

我有以下代码.它给我一个java.lang.IllegalMonitorStateException.为什么这样,我该如何解决这个问题？

public class Threads  {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //Thread Th = new Threads();
        Thread th = new Thread (new thread1 ());
        th.start();
        Thread th1 = new Thread (new thread1 ());
        th1.start();
    }
}



class thread1 implements Runnable{
    String name = "vimal";
    static int id = 0;
    public void run() {
        System.out.println("Runnable "+this.name);
        //setNAme("Manish");
        synchronized(name){
            System.out.println(this.name);
            this.name = "Manish "+this.id;
            this.id++;
            try {
                wait(1000);System.out.println("Thread "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                // TODO Auto-generated …