标签: synchronization

嗨,我做了一个扩展线程的东西,添加添加一个具有IP的对象.然后我做了这个线程的两个实例并启动它们.他们使用相同的列表.

我现在想使用Synchronized来停止并发更新问题.但它没有工作,我无法解决原因.

我的主要课程:

import java.util.*;
import java.io.*;
import java.net.*;

class ListTest2 {
    public static LinkedList<Peer>  myList = new LinkedList<Peer>();

    public static void main(String [] args) {   
        try {
            AddIp test1 = new AddIp(myList);
            AddIp test2 = new AddIp(myList);

            test1.start();
            test2.start();      
        } catch(Exception e) {
            System.out.println("not working");
        }
    }
}

我的线程类:

 class AddIp extends Thread {
     public static int startIp = 0;

     List<Peer> myList;

     public  AddIp(List<Peer> l) {
         myList = l;
     }


     public synchronized void run() {      
        try {
            startIp = …

我有一个在不同线程中使用的数据库对象:

import java.sql.Connection;
import oracle.ucp.jdbc.PoolDataSourceFactory;
import oracle.ucp.jdbc.PoolDataSource;

public class Database
{
  private final PoolDataSource pool = PoolDataSourceFactory.getPoolDataSource();

  protected Connection connect ()
  {
    synchronized (pool) { return pool.getConnection(); }
  }

  protected void disconnect (Connection connection)
  {
    synchronized (pool) { connection.close(); }
  }
}

是否有必要同步对pool成员的访问？或者是否足以避免显式同步？

如果需要同步,则代码将被破坏,因为没有必要调用disconnect以关闭连接.类中的某些代码可以connection.close()绕过同步调用.

假设我的java代码中有2个同步方法:

    public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

假设我有2个操作线程:t1和t2.如果t1在increment()方法上运行并在中途进入休眠状态,则由于锁定,t2将无法在increment()方法上运行.我的问题是t2能够对decrement()和value()进行操作,或者一旦线程访问其中一个同步方法,与对象关联的所有同步方法都会被锁定吗？

静态同步方法怎么样？

我目前正在运行一个高度并发的基准测试,它ConcurrentSkipList从Java集合中访问一个.我发现线程在该方法中被阻塞,更准确地说:

java.util.concurrent.ConcurrentSkipListMap.doGet(ConcurrentSkipListMap.java:828)    
java.util.concurrent.ConcurrentSkipListMap.get(ConcurrentSkipListMap.java:1626)

(这是通过超过10秒的间隔打印每个单独线程的堆栈跟踪获得的).几分钟后仍未解决

这是集合的预期行为吗？什么是可能遇到阻塞的并发其他集合？

经过测试,我表现出与ConcurrentHashMaps 相似的行为:

java.util.concurrent.ConcurrentHashMap.get(ConcurrentHashMap.java:994)

主线程:

(是的,我现在停止主线程,我现在真的需要它进行测试,这是测试单元.我将在最后阶段在另一个线程中完成所有这些工作.)

码:

function TFreHolder.GetVersion: TFreHolderVersion;
Var
 Data   : TBArray;
 StrLen : Integer;
begin
 SetLength(Data, 0);

 FFrePro.SendCommand(PROTO_COMVERSION, Data);

 ResetEvent(FAsyncMutex);

 if (WaitForSingleObject(FAsyncMutex, PROTO_COMMANDTIMEOUT) = WAIT_TIMEOUT) Then
  Begin
   ShowMessage('Timeout');
   ResetEvent(FAsyncMutex);
   Exit;
  End;

Result.DType    := BytesToWord(FActivePackage.User.Parameters, 0);
Result.DVersion := BytesToWord(FActivePackage.User.Parameters, 2);
StrLen          := BytesToByte(FActivePackage.User.Parameters, 4);

if StrLen < 32
  then Result.DDesc    := BytesToString(FActivePackage.User.Parameters, 5)
  else Result.DDesc    := BytesToString(FActivePackage.User.Parameters, 4);

在COM端口监视线程中:

procedure TFreHolder.CommandSwitcher(Package: TFreProPackage);
...
Begin
     FActivePackage := Package;
     SetEvent(FAsyncMutex)
End;
...

我总是看到超时消息,但如果我评论Waitforsingleobject我可以看到字节和包来了.

我用这种方式在Constructor中创建了Event:

FAsyncMutex  := CreateEvent(Nil, True, False, 'FRE_EVENT');

我的错是什么？在获取结果之前,我需要等待CommandSwitcher函数的调用.

谢谢.

我试图用symmetricds配置mysql来postgres与变革同步.我在初始负载时具有非常低的插入性能,100%CPU负载postgres.当我查看postgres日志时,我发现它已经使用了INSERT.它可以正常工作,但不能用于初始化,因为我有数百万条记录.我建立PostgresBulkDatabaseWriter了源代码,它使用COPY而不是INSERT它看起来像一个很好的解决方案(COPYsql请求对我很好),但我没有找到我如何使用它.

所以我的问题:

如何更好地symmetricds为数百万条记录进行初始加载？

如何启用PostgresBulkDatabaseWriter初始(反向初始)加载？

谢谢

UPD:

来源表mysql:

CREATE TABLE `companies` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `cid` int(11) NOT NULL,
  `universalName` text NOT NULL,
  `name` text NOT NULL,
  `country` text NOT NULL,
  `city` text NOT NULL,
  `street` text NOT NULL,
  `phone` text NOT NULL,
  `foundedYear` text NOT NULL,
  `employeeCountRange` text NOT NULL,
  `specialties` …

当您调用外部.exe命令时,如何使PowerShell阻塞直到外部结束？

考虑以下代码:(注意:为了代码清晰,删除了所有try/catch)

Object lock1 = new Object();
Object lock2 = new Object();
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();

public void process() {
    for (int i = 0; i < 1000; i++) {
        methodA();
        methodB();
    }
}

public void methodA() {

    synchronized (lock1) {
        Thread.sleep(1); // mimics other operations
        list1.add(random.nextInt(100));
    }
}

public void methodB() {

    synchronized (lock2) {
        Thread.sleep(1); // mimics other operations
        list2.add(random.nextInt(100));
    }
}

现在假设创建了2个线程,并且两个线程都只是调用process()它们的方法run().

假设当thread2尝试访问时,thread1 methodA()已经锁定了.根据我的理解,thread2将跳过同步锁定,退出methodA()和启动methodB …

我在操作系统中遇到了与我的代码行为混淆的问题.现在你们都有很多方法可以为多线程进行同步,以便无论如何都能获得正确的值!

为什么我总是得到正确的价值而不使用同步的方式??? !

例如,查看下面的代码

在常规行为中,下面的程序应该在几秒后终止..因为有十个线程访问同一个变量并将其递增一个......并且在某些情况下应该导致计数值不是100000 ...这将停止循环..我在20分钟内运行此代码..它完美地工作..

任何人都可以告诉我发生了什么:D ??

我的操作系统是Windows 7,我正在使用eclipse Kepler .. JVM是8 ..而我的CPU不是双核......它是一个常规的独奏......有2.4 GHZ ......

public class Worker {
    int count;

    public static void main(String[] args) {
        new Worker().run();
    }

    public void run() {
        do {
            count = 0;
            Thread thread1 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread2 = new Thread(new Runnable() {
                public void run() {
                    for (int i = …

我有一个单独的线程需要请求一些可能在此期间在JavaFX线程内发生变化的数据.我想在这个单独的线程中执行一个阻塞调用,以确保请求被引入JavaFX线程.

Swing-GUI测试框架AssertJ为此提供了一个易于使用的API:

List list = GuiActionRunner.execute(new GuiQuery<...>...);

调用阻塞当前线程,在事件调度线程中执行传递的代码并返回所需的数据.

如何在JavaFX应用程序的生产代码中实现？这个要求的推荐方法是什么？