线程之示例

一.多种方式解决一个生产者与消费者问题
二.交替打印问题
1.A、B两个线程交替打印1 -- 100
2.Java实现两个线程交替打印问题
3.java多线程交替打印A和B?
4.java多线程 更优雅的实现线程同步：交替打印A、B LockSupport实现

一. 如何解决一个生产者与消费者问题

多线程同步经典问题。生产者和消费者同时使用一块缓冲区，生产者生产商品放入缓冲区，消费者从缓冲区中取出商品。需要保证是，当缓冲区满时，生产者不可生产商品；当缓冲区为空时，消费者不可取出商品。

几种解决同步问题的方式

（1）wait()与notify()

（2）Lock与Condition机制

（3）BlockingQueue阻塞队列 

【1】object类的wait()与notify()方法

wait()用在以下场合:
（1）当缓冲区满时，缓冲区调用wait()方法，使得生产者释放锁，当前线程阻塞，其他线程可以获得锁。

（2）当缓冲区空时，缓冲区调用wait()方法，使得消费者释放锁，当前线程阻塞，其他线程可以获得锁。

notify()用在以下场合：
（1）当缓冲区未满时，生产者生产商品放入缓冲区，然后缓冲区调用notify()方法，通知上一个因wait()方法释放锁的线程现在可以去获得锁了，同步块代码执行完成后，释放对象锁，此处的对象锁，锁住的是缓冲区。

（2）当缓冲区不为空时，消费者从缓冲区中取出商品，然后缓冲区调用notify()方法，通知上一个因wait()方法释放锁的线程现在可以去获得锁了，同步块代码执行完成后，释放对象锁。

// 生产者消费者问题
public class ProAndCon {
public static final int MAX_SIZE = 2;
public static LinkedList<Integer> list = new LinkedList<>();
class Producer implements Runnable {
    public void run() {
    synchronized (list) {
    //仓库容量已经达到最大值
    while (list.size() == MAX_SIZE) {
        System.out.println("仓库已满，生产者" + currentThread().getName() + "不可生产.");
        try {
            list.wait();
        } 
    }
    list.add(1);
    System.out.println("生产者" + currentThread().getName() + "生产, 仓库容量为" + list.size());
    list.notify();
    }}}
class Consumer implements Runnable {
    public void run() {
    synchronized (list) {
    while (list.size() == 0) {
        System.out.println("仓库为空，消费者" + currentThread().getName() + "不可消费");
        try {
            list.wait();
        } 
    }
    list.removeFirst();
    System.out.println("消费者" + currentThread().getName() + "消费，仓库容量为" + list.size());
    list.notify();
    }}
  }
public static void main(String[] args) {
    ProAndCon proAndCon = new ProAndCon();
    Producer producer = proAndCon.new Producer();
    Consumer consumer = proAndCon.new Consumer();
    for (int i = 0; i < 10; i++) {
        Thread pro = new Thread(producer);
        pro.start();
        Thread con = new Thread(consumer);
        con.start();
 }}}

【2】Lock与Condition机制

JDK5.0之后，Java提供Lock与Condition机制。Condition接口的await()和signal()是做同步的两种方法，它们功能基本上和Object的wait()、nofity()相同，或者说可以取代它们，但是它们和Lock机制是直接挂钩的。
通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。

public class ProAndCon2 {
    public static final int MAX_SIZE = 2;
    public static LinkedList<Integer> list = new LinkedList<>();
    public static Lock lock = new ReentrantLock();
    //仓库满的条件变量
    public static Condition full = lock.newCondition();
    //仓库空的条件变量
    public static Condition empty = lock.newCondition();
    class Producer implements Runnable {
     public void run() {
        lock.lock();
        while (list.size() == MAX_SIZE) {
            try {
                System.out.println("仓库已满，生产者" +currentThread().getName() + "不可生产.");
                full.await();
            } 
        }
        list.add(1);
        System.out.println("生产者" + currentThread().getName() + "生产, 仓库容量为" + list.size());
        //唤醒其他生产者与消费者线程
        full.signal();
        empty.signal();
        lock.unlock();}
    }
    class Consumer implements Runnable {
    public void run() {
        lock.lock();
        while (list.size() == 0) {
            try {
                System.out.println("仓库为空，消费者" +currentThread().getName() + "不可消费.");
                empty.await();
            } 
        }
        list.removeFirst();
        System.out.println("消费者" +currentThread().getName() + "消费，仓库容量为" + list.size());
        //唤醒其他生产者与消费者线程
        full.signal();
        empty.signal();
        lock.unlock();
    }}
    public static void main(String[] args) {
    ProAndCon2 proAndCon = new ProAndCon2();
    Producer producer = proAndCon.new Producer();
    Consumer consumer = proAndCon.new Consumer();
    for (int i = 0; i < 10; i++) {
        Thread pro = new Thread(producer);
        pro.start();
        Thread con = new Thread(consumer);
        con.start();
    }
  }}

【3】使用BlockingQueue阻塞队列
什么是阻塞队列？
如果向一个已经满了的队列中添加元素或者从空队列中移除元素，都将会导致线程阻塞，线程一直等待到有旧元素被移除或新元素被添加的时候，才能继续执行。

JDK 1.5 以后新增BlockingQueue接口，我用它实现类，ArrayBlockingQueue或者是LinkedBlockingQueue。

怎么使用LinkedBlockingQueue？
用LinkedBlockingQueue来解决生产者与消费者问题，主要用到它put()与take()

put():向阻塞队列中添加一个元素，队列满时，自动阻塞。

take():从阻塞队列中取出一个元素，队列空时，自动阻塞。

原理：其实LinkedBlockingQueue底层使用的仍然是Lock与Condition机制，从源码知道

//..............用到了Lock与Condition机制。 LinkedBlockingQueue底层已经解决好了同步问题，可方便使用它。

  // 解决生产者与消费者问题: 采用阻塞队列BlockingQueue
public class ProAndCon3 {
    public static final int MAX_SIZE = 2;
    public static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(MAX_SIZE);
    class Producer implements Runnable {
        public void run() {
            if (queue.size() == MAX_SIZE) {
                System.out.println("仓库已满，生产者" + currentThread().getName() + "不可生产.");
            }
            try {
                queue.put(1);
                System.out.println("生产者" +currentThread().getName() + "生产, 仓库容量为" + queue.size());
            } 
        }}
    class Consumer implements Runnable {
        public void run() {
            if (queue.size() == 0) {
                System.out.println("仓库为空，消费者" + currentThread().getName() + "不可消费.");
            }
            try {
                queue.take();
                System.out.println("消费者" + currentThread().getName() + "消费，仓库容量为" + queue.size());
            } 
        }}
    public static void main(String[] args) {
        ProAndCon3 proAndCon = new ProAndCon3();
        Producer producer = proAndCon.new Producer();
        Consumer consumer = proAndCon.new Consumer();
        for (int i = 0; i < 10; i++) {
            Thread pro = new Thread(producer);
            pro.start();
            Thread con = new Thread(consumer);
            con.start();
     }}}

二. 多线程交替打印问题

2.1. 多线程交替打印A和B?

关键就是打印A和B的方法，synchronized的对象是同一个，即持有的锁是同一个，都是print这个类的实例
然后又一个标志，当不是自己的时候，就释放自己的锁，并让线程进入等待状态，就是this.wait（）
当while执行完后，说明到自己的回合，打印字符，设置标志，然后唤醒锁为this的线程。

class Print{
boolean nowA=true;
 synchronized void printA(){
    while(!nowA){
        try {
            this.wait();
        } 
    }
    nowA=false;
    System.out.println(Thread.currentThread()+""+"A");
    this.notify();
}
 synchronized void printB(){
    while(nowA){
        try {
            this.wait();
        } 
    }
    nowA=true;
    System.out.println(Thread.currentThread()+" "+"B");
    this.notify();
}}
public class Test3 {
    public static void main(String[] args){
        Print print=new Print();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    print.printA();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    print.printB();
                }
            }
        }).start();;
}}

2.2 .java多线程 更优雅的实现线程同步：交替打印A、B LockSupport实现

一 问题概述
  线程或者进程之间有两种关系:同步和互斥，通常实现同步方法是使用线程的等待唤醒机制，而等待唤醒机制使用是建立在互斥继承上的。
  但是同步线程并不一定是必须要实现互斥的。比如一个线程打印A，一个线程打印B。这两个线程就没有互斥关系，但是提出这么个需求：交替打印A、B ,
  一般往往要使用wait()/notify机制。
二 LockSupport 介绍
    LockSupport作为一个工具类，主要学习它的方法。
    park():在线程内调用，表示当前线程自我阻塞，直到获得许可证
    park(线程变量)：让指定的线程获得许可证。
    一看这两个方法的定义，显然可以利用这两个方法实现线程的顺序调用（同步）
三 两种思路实现交替打印A/B
  * 交替打印A/B 等待唤醒机制

 public class Test3 {
  static class MyRun implements Runnable {
    static int i = 0;
    @Override
    public synchronized  void run() {
        for (int j = 0; j < 10; j++) {
            if(i%2==0)
                System.out.println(Thread.currentThread().getName()+":A");
            else
                System.out.println(Thread.currentThread().getName()+":B");
            i++;
            this.notifyAll();
            try {
                if(i>=19)
                    Thread.sleep(10);
                else
                    this.wait();
    } }
}}
 public static void main(String[] args) {
    MyRun myRun = new MyRun();
    Thread a = new Thread(myRun);
    Thread b = new Thread(myRun);
    a.start();
    b.start();
}}
//LockSupport实现: 交替打印A,B LockSupport实现
public class Test2 {
 static Thread a=null;
 static Thread b=null;
public static void main(String[] args) {
    a= new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.println(currentThread().getName()+":B");
                LockSupport.unpark(b);
            }
        }});
    b=new Thread((new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(currentThread().getName()+":A");
                LockSupport.unpark(a);
                LockSupport.park();
            }
        }}));
    a.start();
    b.start();
}}

2.3 Java实现两个线程交替打印问题
线程1负责打印a,b,c,d
线程2负责打印1,2,3,4；要求控制台中输出的内容为 a1b2c3d4

public class TestMain {
 static final Object object = new Object();
 public static void main(String[] args) throws InterruptedException {
    new Thread(new Runnable() {
        String a[] = {"a","b","c","d"};
        @Override
        public void run() {
        for(int i=0;i< 4 ;i++){
           synchronized (object){
            System.out.println("线程a 开始执行");
            object.notify();
            try {
                System.out.println("线程a 开始等待");
                object.wait();
            }
            System.out.println("线程a 继续执行");
            System.out.println(a[i]);
            System.out.println("线程a 执行结束");
            object.notify();
          }}
        }}).start();
    new Thread(new Runnable() {
        int a[] = {1,2,3,4};
        @Override
        public void run() {
         for(int i=0;i<4;i++){
          synchronized (object){
            System.out.println("线程1 开始执行");
            object.notify();
            try {
                System.out.println("线程1 开始等待");
                object.wait();
            }
            System.out.println("线程1 继续执行");
            System.out.println(a[i]);
            System.out.println("线程1 执行结束");
           }
    } }}).start();
}}

2.4 .A、B两个线程交替打印1 -- 100

方案一：
public class Test100_02 {
 private static Object object = new Object();
 private static boolean isFlag = false;
 public static void main(String[] args) {
   Thread t1 = new Thread(() -> {
    for (int i = 1; i <= 999; i+=2) {
        synchronized (object) {
            if (!isFlag) {
                System.out.println("current:" + i);
                isFlag = true;
                try {
                    object.wait();
                } 
                object.notify();
            }
        }
    }});
  Thread t2 = new Thread(() -> {
    for (int i = 2; i <= 1000; i+=2) {
      synchronized (object) {
        if (isFlag) {
            isFlag = false;
            System.out.println("current:" + i);
            object.notify();
            try {
                object.wait();
            } }
        }}
    });
    t1.setPriority(Thread.MAX_PRIORITY);
    t1.start();
    t2.start();
}}

方案二：
public class Test100_01 {
 private static Lock lock = new ReentrantLock();
 private static Condition condition1 = lock.newCondition();
 private static Condition condition2 = lock.newCondition();
 public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
    for (int i = 1; i <= 999; i += 2) {
        lock.lock();
        try {
            System.out.println("current:" + i);
            condition1.await();
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.unlock();
    }});
    Thread t2 = new Thread(() -> {
        for (int i = 2; i <= 1000; i += 2) {
            lock.lock();
            try {
                System.out.println("current:" + i);
                condition1.signal();
                condition2.await();
            } 
            lock.unlock();
        }
    });
    t1.setPriority(Thread.MAX_PRIORITY);
    t1.start();
    t2.start();
}}
你的代码我运行了貌似会在中途卡住，
我改进了一下顺序
condition2.signal();
System.out.println("current:" + i);
condition1.await();
condition1.signal();
System.out.println("current:" + i);
condition2.await();

41.生产者消费者模式
class Clerk {//店员类
    private int product = 0;
    public synchronized void get() {// 进货
        while (product >= 1) {
          System.out.println("产品已满！");
          try {
          this.wait();} 
        }
       System.out.println(currentThread().getName() + ":" + ++product);
       this.notifyAll(); // 唤醒
    }
    public synchronized void sale() {// 售货
        while (product <= 0) {
          System.out.println("缺货！");
         try {
          this.wait();// 等待} 
        }
        System.out.println(currentThread().getName() + ":" + --product);
        this.notifyAll();// 唤醒}
}
class Productor implements Runnable {// 生产者类
    private Clerk clerk;
    public Productor(Clerk clerk) {
      this.clerk = clerk;
    }
    @Override
    public void run() {
     for (int i = 0; i < 10; i++) {
        try {
         Thread.sleep(100);
        }
         clerk.get();}
    }
}
class Consumer implements Runnable {// 消费者类
    private Clerk clerk;
    public Consumer(Clerk clerk) {
      this.clerk = clerk;
    }
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
       clerk.sale();
       }}
    }
public class TestProductorAndConsumer {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor productor = new Productor(clerk);
        Consumer consumer = new Consumer(clerk);
        new Thread(productor, "Productor A").start();
        new Thread(consumer, "Consumer B").start();
        new Thread(productor, "Productor C").start();
        new Thread(consumer, "Consumer D").start(); }
}

42.线程交替打印
//其他方法: https://segmentfault.com/a/1190000021433079?utm_source=sf-similar-article
//**** 1) 3个线程交替打印0->100
public class Main012 {
    public static void main(String[] args) {
        int threadCount = 3;
        int max = 100;
        for (int i = 0; i < threadCount; i++) {
           new Thread(new PrintSequenceThread(i, threadCount, max)).start();}
    }
}
class PrintSequenceThread implements Runnable {
    private static final Object mLock = new Object();
    private static int current = 0;//当前即将打印的数字
    private int threadNo;//前线程编号，从0开始
    private int threadCount;
    private int max;//打印的最大值
    public PrintSequenceThread(int threadNo, int threadCount, int max) {
      this.threadNo = threadNo;
      this.threadCount = threadCount;
      this.max = max;
    }
    public void run() {
      while (true) {
        synchronized (mLock) {
        // 判断是否轮到当前线程执行
         while (current % threadCount != threadNo) {
         if (current > max) {break;}
          try {
           mLock.wait();// 如果不是，则当前线程进入wait
          }
         }
        // 最大值跳出循环
        if (current > max) {break;}
          System.out.println("thread-" + threadNo + " : " + current);
          current++;
          mLock.notifyAll();  //唤醒其他wait线程
        }
      }}
}
//************ 
//2) 3个线程并发打印从0到n，不是交替打印,每个线程可能连续执行,有的线程可能长时间按得不到执行
public class Main12_1 {
    public static void main(String[] args) {
        int threadCount = 3;
        for (int i = 0; i < threadCount; i++) {
          new Thread(new PrintSequenceThread1(i, threadCount)).start();
        }
    }
}
class PrintSequenceThread1 implements Runnable {
    private static final Object mLock = new Object();
    private static int current = 0; // 当前即将打印的数字
    private int threadNo;  // 当前线程编号，从0开始
    private int threadCount;
    public PrintSequenceThread1(int threadNo, int threadCount) {
      this.threadNo = threadNo;
      this.threadCount = threadCount;
    }
    @Override
    public void run() {//3个线程并发打印从0到n，不是交替打印,每个线程可能连续执行,有的线程可能长时间按得不到执行
     while (true) {
     synchronized (mLock) {
      try {
      Thread.sleep(100);
      } 
      System.out.println("thread-" + threadNo + " : " + current);
      current++;
      }}
    }
}
//**** 3) 3个线程交替打印从0到n 
public class Main12_2 {
    public static void main(String[] args) {
    int threadCount = 3;
    for (int i = 0; i < threadCount; i++) {
      //3个线程交替打印从0到n
      new Thread(new PrintSequenceThread2(i, threadCount)).start();
    }}
}
class PrintSequenceThread2 implements Runnable {
    private static final Object mLock = new Object();
    private static int current = 0;//当前即将打印的数字
    private int threadNo;// 当前线程编号，从0开始
    private int threadCount;//线程数量
    public PrintSequenceThread2(int threadNo, int threadCount) {
      this.threadNo = threadNo;
      this.threadCount = threadCount;
    }
    public void run() {//3个线程交替打印从0到n
      while (true) {
        synchronized (mLock) {
          // 判断是否轮到当前线程执行
        while (current % threadCount != threadNo) {//一定是while，而不是if
        try {
        //是while的原因,当这个线程被notifyAll时,它会从mLock.wait()这句之后继续往下执行,即使当前没有轮到它
        //写成while，如果它依然满足条件(没有轮到它),它会一直阻塞在这里
        // 如果不是，则当前线程进入wait
          mLock.wait();
        }
        }
        try {
         Thread.sleep(100);//停顿100ms，为了让打印不要太快
        }
        System.out.println("thread-" + threadNo + " : " + current);
        current++;
        mLock.notifyAll();}
      } 
    }
}

二.  三个线程交替打印ABC

如果要实现3个线程交替打印ABC呢？这次打算使用重入锁，和上面没差多少，但是由于现在有三个线程了，在打印完后需要唤醒其他线程，注意不可使用sigal()，因为唤醒的线程是随机的，不能保证打印顺序不说，还会造成死循环。一定要使用sigalAll()唤醒所有线程。

public class ThreeThreadPrintABC {
     private static ReentrantLock lock = new ReentrantLock();
     private static Condition wait = lock.newCondition();
     // 用来控制该打印的线程
     private static int count = 0;
     static class PrintA implements Runnable {
         @Override
         public void run() {
             for (int i = 0; i < 10; i++) {
                 lock.lock();
                 try {
                     while ((count % 3) != 0) {
                         wait.await();
                     }
                     System.out.println(Thread.currentThread().getName() + " A");
                     count++;
                     wait.signalAll();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     lock.unlock();
                 }
             }
         }
     }
     static class PrintB implements Runnable {
         @Override
         public void run() {
             for (int i = 0; i < 10; i++) {
                 lock.lock();
                 try {
                     while ((count % 3) != 1) {
                         wait.await();
                     }
                     System.out.println(Thread.currentThread().getName() + " B");
                     count++;
                     wait.signalAll();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     lock.unlock();
                 }
             }
         }
     }
     static class PrintC implements Runnable {
         @Override
         public void run() {
             for (int i = 0; i < 10; i++) {
                 lock.lock();
                 try {
                     while ((count % 3) != 2) {
                         wait.await();
                     }
                     System.out.println(Thread.currentThread().getName() + " C");
                     count++;
                     wait.signalAll();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     lock.unlock();
                 }
             }
         }
     }
     public static void main(String[] args) {
         Thread printA = new Thread(new PrintA());
         Thread printB = new Thread(new PrintB());
         Thread printC = new Thread(new PrintC());
         printA.start();
         printB.start();
         printC.start();
     }
}
Thread-0 A
Thread-1 B
Thread-2 C
Thread-0 A
Thread-1 B
Thread-2 C
Thread-0 A
Thread-1 B
Thread-2 C
Thread-0 A
Thread-1 B
Thread-2 C

如果觉得不好理解，重入锁是可以绑定多个条件的。创建3个Condition分别让三个打印线程在上面等待。A打印完了，唤醒等待在conditionB对象上的PrintB；B打印完了唤醒在conditionC对象上的PrintC；C打印完了，唤醒在conditionA对象上等待的PrintA，如此循环地唤醒对方即可。

public class ThreeThreadPrintABC1 {
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();
    // 用来控制该打印的线程
    private static int count = 0;
    static class PrintA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    if (count % 3 != 0) {
                        conditionA.await();
                    }
                    System.out.println(Thread.currentThread().getName() + "------A");
                    count++;
                    conditionB.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
    static class PrintB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    if (count % 3 != 1) {
                        conditionB.await();
                    }
                    System.out.println(Thread.currentThread().getName() + "------B");
                    count++;
                    conditionC.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
    static class PrintC implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    if (count % 3 != 2) {
                        conditionC.await();
                    }
                    System.out.println(Thread.currentThread().getName() + "------C");
                    count++;
                    conditionA.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
    public static void main(String[] args) {
        Thread printA = new Thread(new PrintA());
        Thread printB = new Thread(new PrintB());
        Thread printC = new Thread(new PrintC());
        printA.start();
        printB.start();
        printC.start();
    }
}
Thread-0------A
Thread-1------B
Thread-2------C
Thread-0------A
Thread-1------B
Thread-2------C
Thread-0------A
Thread-1------B
Thread-2------C
Thread-0------A
Thread-1------B
Thread-2------C

另一种实现：

/**
 * 基于一个ReentrantLock和三个conditon实现连续打印abcabc...
 */
public class PrintABCTest implements Runnable { 
    // 打印次数
    private static final int PRINT_COUNT = 10;
    // 打印锁
    private final ReentrantLock lock;
    // 本线程打印所需的condition
    private final Condition thisCondition;
    // 下一个线程打印所需的condition
    private final Condition nextCondition;
    // 打印字符
    private final char printChar;
    public PrintABCTest(ReentrantLock lock, Condition thisCondition, Condition nextCondition, char printChar) {
        this.lock = lock;
        this.thisCondition = thisCondition;
        this.nextCondition = nextCondition;
        this.printChar = printChar;
    }
    @Override
    public void run() {
        // 获取打印锁 进入临界区
        lock.lock();
        try {
            // 连续打印PRINT_COUNT次
            for (int i = 0; i < PRINT_COUNT; i++) {
                //打印字符
                System.out.println(printChar);
                // 使用nextCondition唤醒下一个线程
                // 因为只有一个线程在等待，所以signal或者signalAll都可以
                nextCondition.signal();
                // 不是最后一次则通过thisCondtion等待被唤醒
                // 必须要加判断，不然虽然能够打印10次，但10次后就会直接死锁
                if (i < PRINT_COUNT -1) {
                    try {
                        // 本线程让出锁并等待唤醒
                        thisCondition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } finally {
            // 释放打印锁
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        // 写锁
        ReentrantLock lock = new ReentrantLock();
        // 打印a线程的condition
        Condition conditionA = lock.newCondition();
        // 打印b线程的condition
        Condition conditionB = lock.newCondition();
        // 打印c线程的condition
        Condition conditionC = lock.newCondition();
        // 实例化A线程
        Thread printerA = new Thread(new PrintABCTest(lock, conditionA, conditionB, 'A'));
        // 实例化B线程
        Thread printerB = new Thread(new PrintABCTest(lock, conditionB, conditionC, 'B'));
        // 实例化C线程
        Thread printerC = new Thread(new PrintABCTest(lock, conditionC, conditionA, 'C'));
        // 依次开始A B C线程
        printerA.start();
        Thread.sleep(100);
        printerB.start();
        Thread.sleep(100);
        printerC.start();
    }
}
A
B
C
A
B
C
A
B
C
A
B
C

一.两个线程交替打印奇偶数

方法1：使用同步方法实现

public class Num {
    private int count = 1;
    public synchronized void printOdd() {//打印奇数
        try {
            if (count % 2 != 1) {
                this.wait();
            }
            System.out.println(Thread.currentThread().getName() + "----------" + count);
            count++;
            this.notify();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void printEven() {//打印偶数
        try {
            if (count % 2 != 0) {
                this.wait();
            }
            System.out.println(Thread.currentThread().getName() + "----------" + count);
            count++;
            this.notify();
        } catch (InterruptedException e) {
        }
    }
}
/**
 * 打印奇数的线程
 */
public class Odd implements Runnable{
    private Num num;
    public Odd(Num num) {
        this.num = num;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            num.printOdd();
        }
    }
}
/**
 * 打印偶数的线程
 */
public class Even implements Runnable {
    private Num num;
    public Even(Num num) {
        this.num = num;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            num.printEven();
        }
    }
}
public class TestPrint {
    public static void main(String[] args) {
        Num num = new Num();
        Odd odd = new Odd(num);
        Even even = new Even(num);
        Thread t1 = new Thread(odd, "threadOdd");
        Thread t2 = new Thread(even, "threadEven");
        t1.start();
        t2.start();
    }
}
threadOdd----------1
threadEven----------2
threadOdd----------3
threadEven----------4
threadOdd----------5
threadEven----------6
threadOdd----------7
threadEven----------8
threadOdd----------9
threadEven----------10

方法2：使用同步块实现

public class Number {
    private int count = 1;
    private Object lock = new Object();
    public void printOdd() {//打印奇数
        synchronized(lock) {
            try {
                if(count % 2 != 1) {
                    lock.wait();
                }
                System.out.println(Thread.currentThread().getName() + "=======" + count);
                count++;
                lock.notify();
            } catch(InterruptedException e) {     
            }
        }    
    }
    public void printEven() {//打印偶数
        synchronized(lock) {
            try {
                if(count % 2 != 0) {
                    lock.wait();
                }
                System.out.println(Thread.currentThread().getName() + "=======" + count);
                count++;
                lock.notify();
            } catch(InterruptedException e) {  
            }
        }    
    }
}
/**
 * 打印奇数的线程
 */
public class OddPrinter implements Runnable {
    private Number num;
    public OddPrinter(Number num) {
        this.num = num;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            num.printOdd();
        }
    }
}
/**
 * 打印偶数的线程
 */
public class EvenPrinter implements Runnable{
    private Number num;
    public EvenPrinter(Number num) {
        this.num = num;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            num.printEven();
        }
    }
}
public class PrintOddEven {
    public static void main(String[] args) {
        Number num = new Number();
        OddPrinter oddPrinter = new OddPrinter(num);
        EvenPrinter evenPrinter = new EvenPrinter(num);
        Thread oddThread = new Thread(oddPrinter, "oddThread");
        Thread evenThread = new Thread(evenPrinter, "evenThread");
        oddThread.start();
        evenThread.start();
    }
}
oddThread=======1
evenThread=======2
oddThread=======3
evenThread=======4
oddThread=======5
evenThread=======6
oddThread=======7
evenThread=======8
oddThread=======9
evenThread=======10

方法3：使用ReentrantLock实现

public class Number1 {
    private int count = 1;
    private ReentrantLock lock = new ReentrantLock();
    // 为打印奇数的线程注册一个Condition
    public Condition conditionOdd = lock.newCondition();
    // 为打印偶数的线程注册一个Condition
    public Condition conditionEven = lock.newCondition();
    public void printOdd() {//打印奇数
        try {
            lock.lock();
            if(count % 2 != 1) {
                conditionOdd.await();
            }
            System.out.println(Thread.currentThread().getName() + "=======" + count);
            count++;
            conditionEven.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printEven() {//打印偶数
        try {
            lock.lock();
            if(count % 2 != 0) {
                conditionEven.await();
            }
            System.out.println(Thread.currentThread().getName() + "=======" + count);
            count++;
            conditionOdd.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class PrintOddEven1 {
    public static void main(String[] args) {
        final Number1 num = new Number1();
        /**
         * 打印奇数的线程
         */
        Thread oddThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    num.printOdd();
                }
            }
        }, "oddThread");
        /**
         * 打印偶数的线程
         */
        Thread evenThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    num.printEven();
                }
            }
        }, "evenThread");
        oddThread.start();
        evenThread.start();
    }
}
oddThread=======1
evenThread=======2
oddThread=======3
evenThread=======4
oddThread=======5
evenThread=======6
oddThread=======7
evenThread=======8
oddThread=======9
evenThread=======10