0

在工作培训中，我正在编写一个应满足以下条件的 Java（我有 0 经验）程序：

编写一个复制分布式计算应用程序的程序

创建包含 M 个随机数列表的中央“调度程序”对象

创建 N 个处理器线程，从调度程序中检索一个数字，然后在请求另一个数字之前循环多次

如果调度程序没有可用的号码，请等待请求另一个号码。

如果没有更多的数字，则所有线程都应该结束。

到目前为止，我创建了一个包含随机数数组的对象，但我真的不知道如何进行多线程处理。有人可以指导我完成吗？这是我到目前为止所拥有的，以及指示伪代码的注释。

public class ThreadDemo extends Thread
{
    //create new array of arbitrary size 5
    static int SIZE = 5;
    static int[] myIntArray = new int[SIZE];
    
    
    public ThreadDemo()
    {
        start();
    }
    
    class RunnableThread implements Runnable {

        Thread runner;
        public RunnableThread() {
        }
        public RunnableThread(String threadName) {
            runner = new Thread(this, threadName); // (1) Create a new thread.
            System.out.println(runner.getName());
            runner.start(); // (2) Start the thread.
        }
        public void run() {
            //Display info about this particular thread
            System.out.println(Thread.currentThread());
        }
    }

    
    public static void main(String[] args)
    {
        for(int i=0; i<SIZE; i++)
        {
            myIntArray[i] = (int)(Math.random() * 10);
        }
        
        ThreadDemo scheduler = new ThreadDemo();
        
        //create M processor threads that retrieve number from scheduler
            //for(int i=0; i<SIZE; i++)
                //
        
        //if no threads available
            //make the scheduler thread wait() ??
        
        //if empty
            //stop() the scheduler thread ??
        
    }

    }

谁能引导我朝着正确的方向前进？

谢谢！

4

4 回答 4

2

这是一个很好的起点。IT 也将有助于查看executor 服务。这是一个例子。

您可能还想看看一些并发集合。使用队列而不是数组可能值得使用，这样可以更清晰地判断何时从其中拉出某些内容。

于 2012-07-06T12:54:02.383 回答
2

作为第一个指针：不要在构造函数中启动线程，也不要使用Runnable对象来启动使用自身的线程。对于阅读代码的人来说，这非常令人困惑。

这是我对这个问题的看法（希望我没有得意忘形）：

class Scheduler {
    private int[] numbers;
    private AtomicInteger current = new AtomicInteger();

    public Scheduler(int count) {
        Random rand = new Random();
        numbers = new int[count];
        for(int i = 0; i < count; i++) {
            numbers[i] = rand.nextInt();
            if(numbers[i] < 0) numbers[i] *= -1;
        }   
    }

    public int getNextNumber() {
        int local = current.incrementAndGet();
        if(local >= numbers.length) {
            return -1;
        }
        return numbers[local];
    }
}

首先，我们定义了一个Scheduler类，它包含一个随机（正）整数数组，并根据一个原子递增的计数器从数组中按需返回一个数字。

class Task implements Runnable {

    private Scheduler scheduler;  

    public Task(Scheduler scheduler) {
        this.scheduler = scheduler;     
    }

    public void run() {
        while(true) {           
            int limit = scheduler.getNextNumber(); // get next number
            if(limit == -1) return; // no more numbers
            System.out.println(limit);
            for(int i = 0; i < limit; i++) {
                // spin
            }
        }
    }       
}

该类Task包含每个线程执行的代码。每个线程无限循环地从 请求数字Scheduler，直到数组耗尽。

public class Test {

    public static void main(String[] args) throws InterruptedException {

        Scheduler s = new Scheduler(100);
        ExecutorService exec = Executors.newFixedThreadPool(4);
        for(int i = 0; i < 4; i++) {
            exec.submit(new Task(s));
        }

        exec.shutdown();
        exec.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);       
    }
}

在主类中，我们设置了一个线程池，并执行了 4 个线程来完成上述任务。

于 2012-07-06T13:11:36.200 回答
1

您可能想看看 te ThreadPoolExecutor

你应该最终得到这样的东西。

public static void main(){
    ThreadPoolExecutor tpe = new ThreadPoolExecutor(...);
    List<Integer> numbers = getNumberList();
    for(Integer i : numbers){
    tpe.submit(new MyRunnable(i) {
            Integer i;
            public MyRunnable(Integer i){
              this.i=i;
            }
        @Override
        public void run() {
         dosomethingWith(i);
        }
      }
   }

}

于 2012-07-06T12:53:51.227 回答
1

根据我对您的作业的理解，您需要创建一个生产者和工作线程单元。请参考以下链接，这将适合您的要求。

http://www.exampledepot.com/egs/java.lang/WorkQueue.html

谢谢塔尼卡查兰

于 2012-07-06T12:58:14.863 回答