Question

我试图在少数人之间进行模拟谈判（比方说6）。谈判是成对的，意味着在这种情况下：3同时谈判。

我想过运行3个线程（neg1.run（），neg2.run（），neg3.run（）），但事情是我想在协商结束后再次运行它们，并且它们是免费的再次谈判。这必须使用一个线程，因为在协商过程中很少有参数被更改，我需要获得最新的值。

我想创建一个谈判者队列，一旦其中一个人完成了跑步，他将返回队列并等待另一个＆＃34;呼叫＆＃34;。

问题是，我不知道如何处理召回谈判（启动另一个线程）。

Answer 1

这是一个快速而肮脏的版本。我愿意接受建议和批评，并会相应地进行编辑（或者如果你愿意，可以编辑它）。也许我创造了太多的线程？

import java.util.ArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class Main {

public static void main(String[] args) {
    ArrayList<Person> personList = new ArrayList<Person>(6);
    personList.add(new Person("George"));
    personList.add(new Person("John"));
    personList.add(new Person("Mary"));
    personList.add(new Person("Linda"));
    personList.add(new Person("William"));
    personList.add(new Person("Albert"));

    ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors
            .newFixedThreadPool(personList.size() / 2);

    while (true) {
        if (executor.getActiveCount() < executor.getMaximumPoolSize()) {
            executor.execute(new Negotiation(personList));
        } else {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

}

public class Person {
String name;
String lastContact = "";
boolean busy;

public Person(String name) {
    this.name = name;
}

public synchronized boolean approach() {
    if (!busy) {
        return busy = true;
    } else
        return false;
}

public synchronized boolean leave() {
    if (busy) {
        busy = false;
        return true;
    } else
        return false;
}

public String getName(){
    return name;
}

public String getLastContact(){
    return lastContact;
}

public void setLastContact(String partnerName){
    lastContact = partnerName;
}

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Negotiation implements Runnable {
Random rand = new Random();
ArrayList<Person> personList = new ArrayList<Person>(6);
Person convStarter;
Person convPartner;

public Negotiation(ArrayList<Person> personList) {
    this.personList = personList;
}

private Person findPerson(ArrayList<Person> personList) {
    long seed = System.nanoTime();
    Collections.shuffle(personList, new Random(seed));
    for (Person person : personList) {
        if (person.approach()) {
            return person;
        }
    }
    return null;
}

@Override
public void run() {
    try {
        if ((convStarter = findPerson(personList)) != null) {
            if ((convPartner = findPerson(personList)) != null) {
                if (!convStarter.getLastContact().equals(
                        convPartner.getName())) {
                    System.out.println(convStarter.getName()
                            + " is talking to " + convPartner.getName());
                    convStarter.setLastContact(convPartner.getName());
                    convPartner.setLastContact(convStarter.getName());
                    Thread.sleep(randInt(2000, 10000));  //your actual negotiation
                    System.out.println(convStarter.getName()
                            + " stopped talking to "
                            + convPartner.getName());
                }
                convPartner.leave();
            }
            convStarter.leave();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

public int randInt(int min, int max) {
    return rand.nextInt((max - min) + 1) + min;
}
}

Answer 2

你可以创建＆＃34;谈判＆＃34;作为一个Runnable。并使用java.util.concurrent.ThreadPoolExecutor创建一个包含3个线程的线程池。

每当你想要协商时，只需调用threadpoolexector.execute（）。如果有任何线程可用于进行协商。将会完成。否则池将抛出异常RejectedExecutionException。这将告诉你没有线程可用于进行协商。

试试这个java.util.concurrent.ThreadPoolExecutor。它可能对你想要达到的目标有所帮助。

同时线程运行

2 个答案: