1

问题 ：-

使用 Java，您将如何允许多个线程同时在临界区运行，但上限为 6。不应超过 6 个线程同时访问该线程。

我感觉我所做的解决方案（如下所示）是错误的，因为由于synchronized关键字，只有一个线程可以访问关键部分。如果可能的话，请任何人确认并发布其他解决方案。

我的解决方案

package multiplex;

public class Multiplex {

    private static Multiplex multiplex = new Multiplex();
    private volatile static int counter = 0;

    /**
     * @param args
     */
    public static void main(String[] args) {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                try {
                    multiplex.criticalSection();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        for(int index = 0; index < 100; index++){
            Thread thread = new Thread(run);
            thread.setName("Multiplex"+index);
            thread.start();
        }

    }

    public void criticalSection() throws InterruptedException{
        System.out.println("counter is" + counter);
            synchronized (multiplex) {
                    if(counter <=5 ){
                    counter++;
                    System.out.println("No Counter is " + counter);
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "Hello I am critical");
                    multiplex.notify();

                }else{
                    counter--;
                    System.out.println("Waiting Thread" + Thread.currentThread().getName() + " " + counter);

                    multiplex.wait();
                }

            }
    }
}
4

2 回答 2

5

解决方案是使用Semaphore：

// nrPermits is the number of simultaneous semaphore holders
final Semaphore semaphore = new Semaphore(nrPermits);

// then:

semaphore.acquire(); // blocks until a permit is available
try {
    criticalSection();
} finally {
    semaphore.release();
}

另一种解决方案是使用 boundedThreadPool和策略在线程池已满时暂停任务。这是Executors.newFixedThreadPool()默认的：

final ExecutorService service = Executors.newFixedThreadPool(nrTasks);
// use Runnables or FutureTasks if the threads produce results
于 2013-07-07T07:36:30.567 回答
2

除非在极少数情况下，否则这样做没有多大意义，但您可以使用信号量。

一个更简单的解决方案是拥有一个固定大小的 6 个线程池并向其提交 Runnable 任务。这将更有效率，但也更容易写/读。

于 2013-07-07T07:38:02.323 回答