当任务通过执行器服务提交给线程池中的线程时，如何保证一次只能有1个线程占用一个同步任务？

Question

我有以下工人阶级 -

public class Worker implements Runnable {
    private int workId;

    public Worker(int workId) {
        this.workId = workId;
    }

    private int count = 0;

    private synchronized void increment() {
        System.out.println("Work id: " + workId);
        System.out.println("Incrementing...");
        Thread.sleep(5000);
        count++;
        System.out.println("Incremented");
    }

    @Override
    public void run() {
        increment();
    }
}

我有以下主要方法-

ExecutorService executorService = Executors.newFixedThreadPool(2);
        for (int i = 1; i <= 10; i++) {
            executorService.submit(new Worker(i));
        }
        executorService.shutdown();
        System.out.println("All tasks submitted");
        executorService.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("All tasks completed");

此处increment() 已同步。因此，当 1 个线程占用它时，另一个线程必须等到该线程离开锁。

但是当我使用 2 个线程的线程池提交工作时，两个线程似乎同时使用 increment()。

那么在这里我怎样才能强制两个线程一次只使用一个increment() 方法呢？

Answer 1

private synchronized void increment() 

此方法锁定在Object 级别起作用，因此如果您有两个对象，它们在调用此方法时不会相互阻塞，因为每个对象都会调用自己的 increment() 方法（同一个Worker 实例上没有并发调用）。

---

为了避免不同的实例同时访问increment() 方法，您需要在Class 级别进行同步，这是在所有Worker 实例的锁相同时实现的。声明锁的一些选项：

• 共享Object

  public class Boss extends RichDad implements EarnLotsOfMoney
  {
     private final Object masterLock;
     public Boss() 
     {
        masterLock = new Object();
     }
     public Worker createWorker(int slaveId) 
     {
        return new Worker(masterLock, slaveId);
     }
     //...
  }
  

  是的，我知道的愚蠢的例子..

  public class Worker implements Runnable 
  {
     private final Object lock;
     private int workId;
  
     public Worker(Object lock, int workId) 
     {
        this.lock = lock;
        this.workId = workId;
     }
  
     private void increment() 
     {
         synchronized(lock) /*lock holds the same reference in all instances*/
         {
             //...
         }
     }
  
     @Override
     public void run() {
         increment();
     }
  }
  

lock 只创建一次，然后在创建Worker 实例时作为参数传递。这将阻止所有Worker 实例从同一个 Boss 创建（在这种方法中lock 是一个非静态对象）。

---

• 自己的Class

  public class Worker implements Runnable 
  {
     private int workId;
     public Worker(int workId) {
        this.workId = workId;
     }
  
     private int count = 0;
  
     private void increment() 
     {
         synchronized(Worker.class) /*class level lock here*/
         {
           System.out.println("Work id: " + workId);
           System.out.println("Incrementing...");
           Thread.sleep(5000);
           count++;
           System.out.println("Incremented");
         }
     }
  
     @Override
     public void run() {
         increment();
     }
  }
  

这将使用共享的Worker 类作为锁来同步线程。