小编use*_*513的帖子

我有以下情况:

1. 一个只能扩展的数据结构(我只在尾部添加东西)
2. 我需要能够跟踪我已经看到的元素(我有一个索引,理想情况下我希望能够从这个特定元素再次开始遍历列表)
3. 我希望读取永远不会被阻塞,并且添加新元素只能锁定队列的尾部而不是整个队列

这是一个由多个线程严重修改的结构.

什么是最好的数据结构？

ArrayList.这对于能够直接访问使用索引看到的最后一个元素是理想的,但它会导致并发修改异常.我可以使它同步,但希望避免锁定(或任何锁定与最后一个元素分开,因为它是唯一一个可能有并发写入添加新元素的元素)

ConcurrentLinkedQueue.这将解决我的并发问题,但问题是我必须存储迭代的当前位置而不是整数索引.这有一个问题,它返回一个弱一致的迭代器,它不能保证返回自创建迭代器以来已添加到列表中的新对象(source:javadoc)

ConcurrentHashMap,索引为键.这样做的好处是我可以直接访问与正确索引相对应的数据,但是存在的问题是没有"getNext"运算符可以让我有效地遍历从索引到索引+ 1等的元素

向量这将解决我的大多数问题,允许不会抛出并发修改异常并允许直接访问的东西.但是,鉴于所有方法都是同步的,与arraylists相比,性能较差.鉴于我只想扩展结构,而不是在中间插入记录,我不愿意采用这种重量级解决方案,其中读取也会受到性能损失(而且,考虑到我的用例,元素的索引)从来没有真正改变,因此不需要同步不是尾部的读取)

自定义数据结构:保留一个我想要存储的对象数组和一个指向该数组尾部的指针(最后一个元素集),当插入一个新对象时,锁定尾部和尾部指向的对象.当对象超过其当前大小时,进行锁定调整大小操作.

什么是最好的策略/任何其他更有效的实施？

我一直在玩Java垃圾收集器的参数,我看到昂贵和频繁的小垃圾收集,因为伊甸园/幸存者空间填满了.这是因为我分配了一个非常大的对象池.我知道的这些对象是"permament",因为它们被重用但永远不会被GCed.因此,我试图找到一种方法来"自动"将这些类型的对象放在旧代而不是新代中.

我目前正在通过分配一个非常大的新一代(以避免非常频繁的小型GC)来解决这个问题,不幸的是,这意味着每个单独的集合都更昂贵.

我希望能够为每个类指定一个使用率,并将其设置为特定类别的对象,我知道永远不会得到GCed(并且非常大)(在他的情况下,它是关于

我的应用程序对延迟很敏感.

我目前的设置是使用最小/最大堆大小为48的CMS.

这可能吗？我已经搜索了每个可能的JVM标志,但找不到任何相关的效果,并且看不到使用自定义类加载器的方法.

我目前正在编写一段代码,我已经确定我的两位数组的串联是瓶颈,并就如何提高它的效率进行辩论.

我的Bit数组建模如下

public BitArray(int size) { 
    int sizeBytes = size / 8 ;
    if (size % 8 !=0) sizeBytes++;
    this.array = new byte[sizeBytes];
    this.size = size ; 
}

其中size是以位为单位的大小.

当有效地连接两个位阵列时的挑战是当将大小为7的位阵列与大小为6的位阵列连接时需要发生的跨越.因此,不可能简单地做两个阵列副本.

我正在调查的解决方案,除了我目前已经实现的以下内容:计算"跨区域"(例如,5位阵列的最后3位).使用systemBit函数从system.array.copy手动设置第二个数组中的3个"跨越位"复制第一个数组.将第二个数组向左移动3做一个System.arraycopy()

目前,我手动设置第二个数组的每个位,如下所示.

问题是,对于位移,操作实际上非常昂贵,因为必须对每个字节进行操作,然后跨越必须再次发生.

关于如何改进上述技术的想法？

这是当前代码表现不佳:

public static BitArray concatenate(BitArray x1_, BitArray x2_) {
    if (x1_ == null) {
        System.out.println("x1 is null");
        int b = x2_.getArray().length;
        byte[] array = new byte[b];
        System.arraycopy(x2_.getArray(), 0, array, 0, b);
        BitArray res = new BitArray(array);
        res.setSize(x2_.getSize());
        return res;
    } else if (x2_ == null) …

我正在试图找到一种方法来找到建立连接的自由端口的数量,理想情况下使用boost :: asio.然后将使用此端口号进行监听(然后才能打开套接字).

粗略地说,有办法吗？

   tcp::resolver::query query("localhost", port); 

端口留空的位置(将其设置为0不起作用)

以前看到的选项都不是便携式的,也不是高效的.

我正在尝试在以下类型的共享内存中构建映射

我像这样创建共享内存区域:

 managed_shared_memory segment(create_only ,"MyMap"  ,size);       

ShMemAllocator_t alloc_inst (segment.get_segment_manager());

 map =   segment.construct<MyMap_t>("MyMap")      
                             (std::less<int>() 
                             ,alloc_inst); 

地图中的值如下:

       typedef pair<MutexType, boost::interprocess::offset_ptr<void> > ValueType ; 

MutexType本身是一个包含read和write mutex的结构(使用read_lock和write_lock); 定义如下:

typedef struct  mutex_struct{ 
   sharable_lock<interprocess_mutex> read_lock(interprocess_mutex, defer_lock); 
  scoped_lock<interprocess_mutex> write_lock(interprocess_mutex, defer_lock); 
} MutexType;

"size"是映射的总大小(就对象而言,所有void指针指向的数据大小的总和).

如何确保此void*数据也位于我创建的此内存段中,如何在现有共享内存区域中实例化它.之所以这样做,这是我想只有只是反复一次分配这个大的缓冲区删除/添加对象到它(地图模型高速缓存),我还没有在其中找到多个对象可以在相同的内存段内被分配办法在地图内.此外,寻求分配MutexType对返回编译错误,指出没有提供"call"操作符.

假设我有一个具有并行度n的ForkJoinPool设置,并且我调用这样的并行计算:

 workpool.submit(
            () -> {
                    objects.values().parallelStream().forEach(obj -> {
                        obj.foo();
                    });
                });

我这样做是为了确保在那里生成的线程在工作池中创建(我有需要隔离的系统的不同组件).现在假设调用它的线程也在这个工作池中执行,我这样做:

 Future<?> wait =  workpool.submit(
            () -> {
                    objects.values().parallelStream().forEach(obj -> {
                        obj.foo();
                    });
                });
 wait.get()

1)我是否阻止了ForkJoinPool中的线程？如果我在期货中有n个线程全部阻止,而在尝试在工作池中安排任务时,这是否会导致死锁？我不清楚ForkJoinPool中的"最大并行度"是否意味着(如果有n个非阻塞任务),总会有n个线程在执行,或者是否有固定数量的线程,无论是否有阻止.如果我使用wait.join()代替wait.join(我不需要检查异常,因为此代码中抛出的任何异常都会生成runtimeexception.如果我理解正确,join()将允许线程在等待时执行排队的任务)

2)如果我通过执行() - > {}创建一个可运行的"包装器"类,我仍然可以获得并行流的轻量级forkjoin任务的好处

3)使用它是否有任何缺点/好处(假设.join()确实实现了我认为它的工作窃取行为):

        CompletableFuture.supplyAsync(this::mylambdafunction, workpool)  
             .thenAccept(this::mynextfunction);

我正在尝试使用ssh_connect和libssh进行连接,但是我收到以下错误.我不知道这意味着什么.有什么想法吗？

[2014/09/30 00:53:00.015877, 2] channel_open:  Creating a channel 43 with 64000 window and 32768 max packet
[2014/09/30 00:53:00.050776, 1] ssh_packet_unimplemented:  Received SSH_MSG_UNIMPLEMENTED (sequence number 3)
[2014/09/30 00:54:59.949316, 1] ssh_socket_exception_callback:  Socket exception callback: 1 (0)
[2014/09/30 00:54:59.949483, 1] ssh_socket_exception_callback:  Socket error: disconnected
Error allocating SFTP session: Socket error: disconnected

这是代码

** Initialises SSH Session **/ 
ssh_session initialise_ssh(char* host, int port) {

  ssh_session my_ssh_session;
  int verbosity = SSH_LOG_PROTOCOL;

  my_ssh_session = ssh_new();

  ssh_options_set(my_ssh_session, SSH_OPTIONS_HOST, host);
  ssh_options_set(my_ssh_session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
  ssh_options_set(my_ssh_session, SSH_OPTIONS_PORT, &port);

  rc = …

我有以下问题。我可以将事务状态设置为“开始、结束或正在进行”。我设置了这个，然后将我的 Transaction 对象序列化到服务器，后者检索它。第一次（当事务处于启动模式时）像魅力一样工作，但是当我重新发送对象时，这次在“正在进行”模式下，服务器继续在“启动”模式下看到它。我已经在序列化之前的行和反序列化之后的行中测试了代码，这绝对是问题所在。任何帮助将不胜感激。相关代码片段如下：

连载

        if ((query instanceof Transaction) && !(trx.getTransactionState()==Consts.trx_start)) System.out.println("Not start");
        oos.writeObject(query);
        oos.flush();

反序列化

    while (true) {
                Object statement = null;

                try {

                    statement = ois.readObject();
                    if ((statement instanceof Transaction) && !(((Transaction) statement).getTransactionState()==Consts.trx_start)) System.out.println("Not start 2");
                    handle_statement(statement, socket);
                } catch (IOException e) {

和交易类：

    public class Transaction extends Statement{

/**
 * 
 */
private static final long serialVersionUID = -2284996855537430822L;
Statement statement_list;
int trx_state; 


/**
 * 
 */
public Transaction() {
    trx_state = Consts.trx_start;; 
}

/**
 * @param statement
 */
public …

考虑以下代码段:

 Object bar1  = new ... ; 
 Object bar2 = new ... ; 


 Object foo = (either bar1 or bar2) ; 

现在,foo在程序的不同时间可以是bar1或bar2.我只想检查synchronized(foo)是否会锁定相应的bar1或bar2.这似乎是最有可能的情况,因为对象不是用Java复制的.它是否正确？

我正在使用Fabric编写脚本,需要远程终止进程.

(这意味着该命令最终以/ bin/bash命令执行)

我目前的代码如下:

在我有一个kill.sh文件中

  /bin/kill  $(ps -ef | grep multiserver.jar | grep -v bin/sh | grep -v /bin/bash | grep -v sh | grep python  | grep -v /usr/bin/java | grep -v /usr/bin/python | grep -v sh  |  awk '{print $2}')

我使用以下命令在远程主机上运行Fabric

     local("scp "  + "kill.sh " + user +"@" + server_address + ":" + directory) 
     run ("chmod u+x kill.sh")
     run("./kill.sh")

但是,我收到以下错误消息

      out: Usage:
      [] out:  kill [options] <pid> [...]


      Fatal error: run() received nonzero return code 1 while …