标签: synchronization

LONG __cdecl InterlockedCompareExchange(
  __inout  LONG volatile *Destination,
  __in     LONG Exchange,
  __in     LONG Comparand
);

返回值
函数返回Destination参数的初始值。

只是好奇。
为什么InterlockedCompareExchange返回初始值？他们这样做是有原因的吗？

我刚刚开始使用Java中的Threads,所以这可能是一个基本问题,但我无法在线找到答案.

我有两个线程可以调用一个同步函数.我理解它的方式,如果第二个线程在第一个线程已经调用它时调用它,第二个线程将等到第一个线程完成后再调用它.但是,我不希望第二个线程完全调用它.

我ConcurrentModificationException用这段代码得到了什么？我有一个synchronized(侦听器)锁.

private void notifyListeners(MediumRendition rendition) {
    if (rendition == null) return;
    synchronized (listeners) {
        for (RenditionEventListener l : listeners) {
            if (l.renditionType.equals(rendition.getType()) && l.mediumId == rendition.getMediumId()) {
                l.listener.onRendition(rendition);
            }
        }
    }
}

public void put(String renditionType, long mediumId, MediumRendition rendition) {
    HashMap<Long, MediumRendition> l = list.get(renditionType);
    if (l == null) {
        l = new HashMap<Long, MediumRendition>();
        list.put(renditionType, l);
    }
    l.put(mediumId, rendition);
    notifyListeners(rendition);
}

public void addRenditionListener(String renditionType, long mediumId, RenditionListener listener) {
    synchronized (listeners) {
        listeners.add(new RenditionEventListener(renditionType, mediumId, …

我有下面的代码(但不起作用)..我需要等到线程完成其工作然后执行然后下一个命令

private void btnPaste_Click(object sender, EventArgs e)
    {
        if (copiedItems != null)
        {
            if (copy)
            {
                System.Threading.Thread thPASTE = new System.Threading.Thread(PasteFromCopy);
                thPASTE.Start(currAddress);
                lock (this)
                {
                    btnRefresh_Click(sender, e);
                }
            }
            else
            {
                System.Threading.Thread thPASTE = new System.Threading.Thread(PasteFromMove);
                thPASTE.Start(currAddress);
                lock (this)
                {
                    btnRefresh_Click(sender, e);
                }
            }
        }
    }

粘贴应该做一些代码,然后我应该刷新列表即时显示..我需要这样做,因为它不适用于我,当我调用线程中的刷新
我怎么办？

任何人都可以告诉我如何将Google日历从Galaxy S3同步到Google Web日历 - 它可以从Google Web日历同步到Galaxy S3设备,但不是其他方式.

我正在攻读java认证,我从Mughal的书中看到了这个例子:

public class Smiley extends Thread
{
    @Override
    public void run()
    { 
        while(true)
        { 
            synchronized(this)
            {
                try
                { 
                    System.out.print(":"); 
                    Thread.sleep(100); 
                    System.out.print("-"); 
                    Thread.sleep(100); 
                    System.out.println(")"); 
                    Thread.sleep(100); 
                }
                catch(InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void main(String[] args)
    {
        new Smiley().start();
        new Smiley().start();
    }
}

目的是每行打印一个笑脸:-).我的问题是,为什么同步实例(这个)不能实现这一点？为什么我们需要在静态级别上同步？

谢谢,

我刚刚完成了一个应用程序,它将数据与服务器同步(在后台运行SyncAdapter).我把它安装在我的手机上,让它在后台运行(我几乎没用过我的手机),我发现23%的应用程序的电池使用量属于我的应用程序,所以我真的需要减少它的电池使用量.

现在我将同步时间设置为30秒.这是一个多用户应用程序,如果其他用户与您进行交互,您会收到通知,我无法将同步时间设置得太高(实际上我想减少它直到看到电池使用情况).

在每次同步时,它始终要求服务器进行任何更改并检查本地数据库中的更改.如果本地数据库中有更改,则将它们发送到服务器,如果我们从服务器检索更改,则将它们应用于本地数据库.

有没有人知道减少电池使用的一些技巧？

有人可以让我知道为什么下面的代码不是线程安全的？我得到的输出是0或45或90.共享资源计数器有一个同步方法,所以我一直期望90输出.我在这里错过了什么吗？请指教.请允许,也让我知道如何使这个代码线程安全.

class Counter{

    long count = 0;

    public synchronized void add(long value){
      this.count += value;
    }
 }
 class CounterThread extends Thread{

    protected Counter counter = null;

    public CounterThread(Counter counter){
       this.counter = counter;
    }

    public void run() {
    for(int i=0; i<10; i++){
          counter.add(i);
       }
    }
 }
 public class Example {

   public static void main(String[] args){

     Counter counter = new Counter();
     Thread  threadA = new CounterThread(counter);
     Thread  threadB = new CounterThread(counter);

     threadA.start();
     threadB.start();

     System.out.println(counter.count);
   }
 }

如果我有这样的课程:

public class Example
{
    ArrayList<String> vector;

    public Example singleton = new Example();

    private Example()
    {
        //Read data from BD and fill the vector. Example vector:  ["foo","voo","faa","vuu","vee"]
    }   



    public synchronized removeElement()
    {
        vector.remove(0);
    }

    public synchronized changeElement()
    {
        vector.set(0,"fii");
    }
}

如果有多个实例在运行且其中一个实例执行该方法removeElement,那么另一个实例的值会发生什么？如果其中一个执行该方法changeElement？

我只是想使用一个集合,按照我过去添加它们的顺序给我项目,并且也是同步的.当然我想动态添加 - 删除项目.我对Java的许多集合感到困惑.如果有人知道答案,请告诉我.