标签: synchronization

我想根据这个问题的例子同步Indy的TIdTCPServer的OnExecute ,但我没有收到字符串.在我直接从服务器的执行发送字符串之前,客户端确实收到了它们,所以我很确定这方面没有问题.

因为我需要一个上下文来将行写入缓冲区,所以ServerSync包含一个属性,执行过程的上下文被分配给该属性.

服务器形式:

unit ServerForm;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, IdBaseComponent, IdComponent, IdCustomTCPServer,
  IdTCPServer, IdContext;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Server: TIdTCPServer;
    memMessages: TMemo;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Execute(AContext: TIdContext);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

uses ServerSync;

{$R *.dfm}


procedure TForm1.Execute(AContext: TIdContext);
var
  Sync : TServerSync;
begin
  Sync := TServerSync.Create(AContext);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Server …

在Java中使用synchronized关键字全部在单个对象和线程中.

我可以调用一个调用非同步方法的同步方法来调用同步方法,而不会阻止第一个同步方法完成的最终同步方法吗？

我认为这个问题肯定是在某个地方被问到的,但是当我寻找它时,我很遗憾地只找到了不同的主题.无论如何这里是代码:

public class A {
    Object lockX = new Object();
    Object lockY = new Object();
    Object lockZ = new Object();
    int c1;
    int c2;

    public void foo1() {
        synchronized(lockX) {
            c1++;
        }
    }

    public void bar1() {
        synchronized(lockY) {
            c1++;
        }
    }

    public void foo2() {
        synchronized(lockZ) {
            c2++;
        }
    }

    public void bar2() {
        synchronized(this) {
            c2++;
        }
    }
}

基本上foo1和bar1不正确.它们使用不同的锁来保护c1,因此事实上c1将不受保护,并且这两个函数可以同时运行.然而我的问题是关于foo2和bar2.他们还好吗？它们也使用不同的锁,但是bar2锁定了整个对象,所以它是否可以防止同时修改c2？

我有这段代码.

public class Main{

    public static void main(String[] args) {
    Main1 main1 = new Main1();
    Main2 main2 = new Main2();
    Thread t1 = new Thread(main1);
    Thread t2 = new Thread(main2);
    t1.start();
    t2.start();
  }
}
public class Main1 extends Thread{
    SynchronizedCounter c = new SynchronizedCounter();
    public void run(){
        System.out.println("Entering Main1");
        c.print();
        System.out.println("Exiting Main1");
    }
}
public class Main2 extends Thread{
    SynchronizedCounter c = new SynchronizedCounter();
    public void run(){
        System.out.println("Entering Main2");
        c.print();
        System.out.println("Exiting Main2");
    }
}
public class SynchronizedCounter {
    public void …

当然,第二个循环永远不会被执行,但仍然很想知道以下示例是否可以归类为死锁.

public class Test {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++)
            System.out.print(i + " ");

        Thread.currentThread().join();

        for (int i = 11; i <= 20; i++)
            System.out.print(i + " ");

    }
}

我目前正在学习Java中的同步.据我所知,同步实例方法获取其对象的锁.

我的程序是一个50个任务,然后给每个线程.每个任务都会向从帐户类创建的Account对象添加一分钱.

帐户类具有余额数据字段和用于存款的同步方法.50个任务有一个帐户字段,指向同一个帐户对象(即共享帐户).一旦调用了run,每个任务都将调用account.deposit实例方法来存入1个单元.

我预计余额将以50个单位结束.令人惊讶的是,该帐户最终有50个或其他余额14,48,33等.

class JavaStudy {
    public static void main(String[] args){

        for (int j = 0; j < 10; j++) {

            Account account = new Account();

            ExecutorService executorPool = Executors.newFixedThreadPool(50);

            for (int i = 0; i < 50; i++) {
                executorPool.execute(new DepositTask(account));
            }

            executorPool.shutdown();

            while(!executorPool.isShutdown()){
            }

            System.out.println(account.getBalance());
        }
    }
}

存款任务类!

class DepositTask implements Runnable {

    private Account account;

    DepositTask(Account account){
       this.account = account;
  }

   @Override
  public void run() {
       account.deposit(1);
  }
}

账户类!

class Account {

    private int …

我需要将日志数据写入来自不同进程的单个文件中.

我正在使用Windows Mutex,它需要Common Language Runtime支持.

Mutex^ m = gcnew Mutex( false,"MyMutex" );
m->WaitOne();
//... File Open and Write ..
m->ReleaseMutex()

我真的需要从C++更改为C++/CLI进行同步吗？

如果不使用原子就可以了.但我需要知道,与本地互斥锁相比,使用此互斥锁是否会降低性能.

NVIDIA建议的简化方法使用__syncthreads()内部条件分支,例如:

if (blockSize >= 512) { if (tid < 256) { sdata[tid] += sdata[tid + 256]; } __syncthreads(); }

要么

for (unsigned int s=blockDim.x/2; s>32; s>>=1)
{
    if (tid < s)
        sdata[tid] += sdata[tid + s];
    __syncthreads();
}

在第二个例子中__syncthreads()是内部for循环体,它也是一个条件分支.

然而,一些在做题提高的问题,__syncthreads()内部条件的分支(例如我能已经下降线程后使用__syncthreads()？和条件syncthreads和死锁(或没有)),答说,__syncthreads()在条件分支可能导致陷入僵局.因此,NVIDIA建议的缩减方法可能会陷入僵局(如果相信答案所依据的文档).

此外,如果_syncthreads()不能在条件分支内部使用,那么我担心许多基本操作被阻止,减少只是一个例子.

那么如何在不使用__syncthreads()条件分支的情况下减少CUDA 呢？或者它是文档中的错误？

这有效:

int _counter;
readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

async void Button_Click(object sender, RoutedEventArgs e)
{
    if (_semaphore.Wait(0))
    {
        Title = $"{ ++_counter}";
        await Task.Delay(1000); // simulate work
        Title = $"{ --_counter}";
        _semaphore.Release();
    }
}

首次单击其他按钮后,将忽略单击,直到工作完成.Tittle可以是1或0.

这不起作用

void Button_Click(object sender, RoutedEventArgs e)
{
    if (_semaphore.Wait(0))
    {
        Test(); // moving code into separate method
        _semaphore.Release();
    }
}

async void Test()
{
    Title = $"{ ++_counter}";
    await Task.Delay(1000); // simulate work
    Title = $"{ --_counter}"; …

鉴于以下输出:

    Path path1 = Paths.get("/Users/someone/foo");
    Path path2 = Paths.get("/Users/someone/foo");
    System.out.println(path1.toString() == path2.toString()); // outputs false
    System.out.println(path1.toString().equals(path2.toString())); // outputs true

给定以下两个线程,两个线程是否可以同时在关键部分运行？

    // Thread 1
    synchronized (path1.toString()) {
        // Critical section
    }

    // Thread 2
    synchronized (path2.toString()) {
        // Critical section
    }