三个线程轮流输出

[XingdiWang]

public class PrintRunable implements Runnable {

    private String name;
    private Object prev;
    private Object self;

    private  PrintRunable(String name, Object prev, Object self) {
        this.name = name;
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        int count = 10;
        while (count > 0) {
            synchronized (prev) {
                synchronized (self) {
                    System.out.print(name);
                    count--;
                    try{
                        Thread.sleep(1);
                    }
                    catch (InterruptedException e){
                        e.printStackTrace();
                    }

                    self.notify();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    public static void main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        PrintRunable pa = new  PrintRunable("A", c, a);
        PrintRunable pb = new  PrintRunable("B", a, b);
        PrintRunable pc = new  PrintRunable("C", b, c);


        new Thread(pa).start();
        Thread.sleep(100);
        new Thread(pb).start();
        Thread.sleep(100);
        new Thread(pc).start();
        Thread.sleep(100);
    }
}

[qjkobe]

以下代码使用AtomicInteger。虽然这个变量是线程安全的。但是以下代码依旧是错误的。因为它仅仅保证了加法是线程安全的，却有可能当B走到加法的时候，C刚走到判断，这时候加法还没有执行。

public class PrintRunable2 implements Runnable {
  private static AtomicInteger currentCount = new AtomicInteger(0);

  private static final Integer MAX_COUNT = 29;

  private static String [] chars = {"A", "B", "C"};

  private String name;

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

  @Override
  public void run() {
    while(currentCount.get()<=MAX_COUNT){
      if(this.name.equals(chars[currentCount.get()%3])){
        printAndPlusOne(this.name);
      }
    }
  }

  public void printAndPlusOne(String content){
    System.out.print(content+ " "+ currentCount.get());

    currentCount.getAndIncrement();
  }

  public static void main(String [] args){
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
    threadPoolExecutor.execute(new PrintRunable2("A"));
    threadPoolExecutor.execute(new PrintRunable2("B"));
    threadPoolExecutor.execute(new PrintRunable2("C"));
    threadPoolExecutor.shutdown();
  }
}

但是如果给if再加上判断，代码就可以正确执行了。

public class PrintRunable2 implements Runnable {
  private static AtomicInteger currentCount = new AtomicInteger(0);

  private static final Integer MAX_COUNT = 29;

  private static String [] chars = {"A", "B", "C"};

  private String name;

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

  @Override
  public void run() {
    while(currentCount.get()<=MAX_COUNT){
      if(this.name.equals(chars[currentCount.get()%3])&&currentCount.get()<=MAX_COUNT){
        printAndPlusOne(this.name);
      }
    }
  }

  public void printAndPlusOne(String content){
    System.out.print(content);

    currentCount.getAndIncrement();
  }

  public static void main(String [] args){
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
    threadPoolExecutor.execute(new PrintRunable2("A"));
    threadPoolExecutor.execute(new PrintRunable2("B"));
    threadPoolExecutor.execute(new PrintRunable2("C"));
    threadPoolExecutor.shutdown();
  }
}

[qjkobe]

  private static String[] chars = {"A", "B", "C"};

  private static final OperateInteger operateInteger = new OperateInteger(0, 30);

  private String name;

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

  @Override
  public void run() {
    while (operateInteger.getCurrentCount() < operateInteger.getMaxCount()) {
      synchronized (operateInteger) {
        if (operateInteger.getCurrentCount() < operateInteger.getMaxCount()) {
          if (this.name.equals(chars[operateInteger.getCurrentCount() % 3])) {
            operateInteger.printAndPlusOne();
            operateInteger.notifyAll();
          } else {
            try {
              operateInteger.wait();
            } catch (Exception e1) {
              e1.printStackTrace();
            }
          }
        }
      }
    }

  }


  public static void main(String[] args) {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
    threadPoolExecutor.execute(new PrintRunable2("A"));
    threadPoolExecutor.execute(new PrintRunable2("B"));
    threadPoolExecutor.execute(new PrintRunable2("C"));
    threadPoolExecutor.shutdown();
  }

  private static class OperateInteger{
    private int currentCount;

    private int maxCount;

    private void printAndPlusOne() {
      System.out.print(chars[currentCount%3]);
      currentCount++;
    }

    public OperateInteger(int currentCount, int maxCount) {
      this.currentCount = currentCount;
      this.maxCount = maxCount;
    }

    public int getCurrentCount() {
      return currentCount;
    }

    public int getMaxCount() {
      return maxCount;
    }
  }

[qjkobe]

public class PrintRunable2 implements Runnable {
  private static Lock lock = new ReentrantLock();

  private static Integer currentCount = 0;

  private static final Integer MAX_COUNT = 30;

  private static String [] chars = {"A", "B", "C"};

  private String name;

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

  @Override
  public void run() {
    while(currentCount<MAX_COUNT){
      //lock() 与 unlock() 必须和 try...finally 配套使用 避免出现异常不解锁
      try{
        lock.lock();
        while(this.name.equals(chars[currentCount%3])&&currentCount<MAX_COUNT){
          printAndPlusOne(this.name);
        }
      }catch (Exception e){
        e.printStackTrace();
      }finally {
        lock.unlock();
      }
    }
  }

  public void printAndPlusOne(String name){
    System.out.print(name);
    currentCount ++;
  }

  public static void main(String [] args){
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
    threadPoolExecutor.execute(new PrintRunable2("A"));
    threadPoolExecutor.execute(new PrintRunable2("B"));
    threadPoolExecutor.execute(new PrintRunable2("C"));
    threadPoolExecutor.shutdown();
  }
}

[qjkobe]

CyclicBarrier可以阻塞n个线程。当阻塞的线程到达n以后。再一起释放

public class PrintRunable2 implements Runnable {
  private static CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

  private static Integer currentCount = 0;

  private static final Integer MAX_COUNT = 30;

  private static String [] chars = {"A", "B", "C"};

  private String name;

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

  @Override
  public void run() {
    while(currentCount<MAX_COUNT){
      while(this.name.equals(chars[currentCount%3]))
        printAndPlusOne(this.name);
      try {
        cyclicBarrier.await();
      }catch (Exception e){
        e.printStackTrace();
      }
    }
  }

  public void printAndPlusOne(String name){
    System.out.print(name);
    currentCount ++;
  }

  public static void main(String [] args){
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
    threadPoolExecutor.execute(new PrintRunable2("A"));
    threadPoolExecutor.execute(new PrintRunable2("B"));
    threadPoolExecutor.execute(new PrintRunable2("C"));
    threadPoolExecutor.shutdown();
  }
}