Question

问题： -

使用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();
                }

            }
    }
}

Answer 1

解决方案是使用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();
}

另一种解决方案是使用有界ThreadPool，以及在线程池已满时将任务置于保持状态的策略。这是Executors.newFixedThreadPool()默认执行的操作：

final ExecutorService service = Executors.newFixedThreadPool(nrTasks);
// use Runnables or FutureTasks if the threads produce results

Answer 2

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

更简单的解决方案是将固定大小的线程池设置为6并向其提交Runnable任务。这将更有效，但写入/读取也更简单。

在Java中实现Multiplex（并发）

2 个答案: