买票用户 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25] | 就位
sys : 开始放票
/**
**票仓[[票0, 票1, 票2, 票3, 票4]]
**增加了5张票
**/
用户[25]的抢票结果为 true[票0]
用户[2]的抢票结果为 true[票1]
用户[4]的抢票结果为 true[票2]
用户[6]的抢票结果为 true[票3]
用户[8]的抢票结果为 true[票4]
/**
**票仓[[票5, 票6, 票7, 票8, 票9]]
**增加了5张票
**/
用户[10]的抢票结果为 true[票5]
用户[12]的抢票结果为 true[票6]
用户[14]的抢票结果为 true[票7]
用户[16]的抢票结果为 true[票8]
用户[18]的抢票结果为 true[票9]
/**
**票仓[[票10, 票11, 票12, 票13, 票14]]
**增加了5张票
**/
用户[20]的抢票结果为 true[票10]
用户[22]的抢票结果为 true[票11]
用户[24]的抢票结果为 true[票12]
用户[1]的抢票结果为 true[票13]
用户[3]的抢票结果为 true[票14]
/**
**票仓[[票15, 票16, 票17, 票18, 票19]]
**增加了5张票
**/
用户[5]的抢票结果为 true[票15]
用户[9]的抢票结果为 true[票16]
用户[7]的抢票结果为 true[票17]
用户[13]的抢票结果为 true[票18]
用户[15]的抢票结果为 true[票19]
/**
**票仓[[票20]]
**增加了1张票
**/
用户[17]的抢票结果为 true[票20]
放票完毕
买票用户 [0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 20, 22, 24, 25] | 抢票成功

package juc.demo;
/*** 抢票的核心类* @author Allen 2017年9月7日**/import java.util.Arrays;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;import juc.demo.runnable.GrabThread;
import juc.demo.runnable.TicketSupplement;/*** 抢票* * @author Allen 2017年9月7日**/
public class GrabTicket {public int TICKET_INDEX = 0;// 票仓当前指针ReentrantLock reentrantlock = new ReentrantLock();// 独占锁Condition condition = reentrantlock.newCondition();// 在AQS中与独占锁配合使用,作为了队列的存在private CyclicBarrier cyclicBarrier;// 建立一个同步屏障public GrabTicket() {this.cyclicBarrier = new CyclicBarrier(Data.USER_NUM, new Runnable() {@Overridepublic void run() {Temp.print("就位"); //当所有用户await后，打印已就位的用户列表System.out.println("sys : 开始放票");addTicket(); //向当前票仓填票}});}public void execute() {ExecutorService threadPool = Executors.newFixedThreadPool(Data.USER_NUM); //启动一个固定长度的线程池来维护for (int i = 0; i < Data.USER_NUM; i++) {threadPool.execute(new GrabThread(cyclicBarrier, this, i + 1)); //每个抢票的用户}threadPool.execute(new TicketSupplement(this));//启动补票线程threadPool.shutdown();}/*** 放票*/public void addTicket() {TICKET_INDEX = 0; //每次放票把放票指针归零 Data.refresh(); //刷新新票到仓库System.out.println("/**");System.out.printf("**票仓[%s]\n", Arrays.toString(Data.TICKETS_NOW));System.out.printf("**增加了%s张票\n", Data.TICKETS_NOW.length);System.out.println("**/");}public void signalAll() { try {reentrantlock.lock(); //condition.signalAll();//独占锁确保可以把reentrantlock中condition队列阻塞的线程全部解阻塞,类似 wait noityAll} finally {reentrantlock.unlock();}}//独占锁确保了同步性，并使用condition来使未得到票的线程，来等待放票后唤醒         public void Grab(int i) throws InterruptedException {String ticketName = null;reentrantlock.lock();try {if (TICKET_INDEX >= Data.TICKETS_NOW.length) { //当前指针超过了容器大小则进入阻塞等待下一次放票condition.await();  //Condition将独占锁中满足条件的放入阻塞队列进行等待，直到signal唤醒Grab(i);//递归来进入Grab抢票} else {ticketName = Data.TICKETS_NOW[TICKET_INDEX++];//通过指针获得当前票号Data.TICKETS_NOW[TICKET_INDEX - 1] = null;//将得到的票设为null标识已经被买走 System.out.printf("用户[%s]的抢票结果为 %s[%s] \n", i, ticketName != null, ticketName);Temp.add(i);//将抢票成功的用户添加到数组中Data.USER_SUM++;//记录抢完票的用户，主要用于当用户数小于票数，放票机进行拦截}} finally {reentrantlock.unlock();//释放锁}}
}
//此类提供启动入口，用户初始化，票仓初始化，以及购票等主要函数 

package juc.demo.runnable;import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;import juc.demo.GrabTicket;
import juc.demo.Temp;/*** 抢票线程* * @author Allen 2017年9月7日**/
public class GrabThread implements Runnable {CyclicBarrier cb;GrabTicket grabTicket;int i;public GrabThread(CyclicBarrier cb, GrabTicket grabTicket, int i) {this.cb = cb;this.grabTicket = grabTicket;this.i = i;}@Overridepublic void run() {Temp.add(i);//添加用户到临时容器try {   cb.await(); //进入await等待,当等待人数满足CyclicBarrier构造传入的num时,condition会唤醒所有awaitgrabTicket.Grab(i);//与其他线程同时购票} catch (InterruptedException | BrokenBarrierException e) {e.printStackTrace();}}
}

package juc.demo.runnable;import java.util.Arrays;import juc.demo.Data;
import juc.demo.GrabTicket;
import juc.demo.Temp;/*** 放票线程* * @author Allen 2017年9月7日**/
public class TicketSupplement implements Runnable {GrabTicket grabTicket;public TicketSupplement(GrabTicket grabTicket) {this.grabTicket = grabTicket;}@Overridepublic void run() {for (;;) {try {Thread.sleep(1000);if (Arrays.asList(Data.TICKETS_NOW).stream().allMatch(this::isNull)) { //确保没票了才放票，网上说火车票是每隔一个时间段就放票。这里增加了没票才放票的逻辑是因为我这里是个demoif (Data.TICKET_INDEX * Data.TICKET_MAX > Data.TICKET_COUNT) {//判断放票是否越界System.out.println("放票完毕");Temp.print("抢票成功");System.exit(-1);} else {grabTicket.addTicket();//放票grabTicket.signalAll();// 补票完毕把condition队列中的等待全部唤醒}} else if(Data.USER_SUM  == Data.USER_NUM){//如果得到票的人和总人数相匹配，则证明没票了。那么这个模拟放票进程就可以关闭了System.out.printf("都抢完票了 %s : [%s张]\n", "余票",Arrays.asList(Data.TICKETS_NOW).stream().filter(this::isNotNull).count());System.exit(-1);}} catch (InterruptedException e) {e.printStackTrace();}}}private boolean isNull(String str) { //方法引用的2个函数return str == null;}private boolean isNotNull(String str) {return !isNull(str);}}

主要就是上面这2个线程与抢票的核心类来提供整个demo服务

买票用户 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] | 就位
sys : 开始放票
/**
**票仓[[票0, 票1, 票2, 票3, 票4]]
**增加了5张票
**/
用户[19]的抢票结果为 true[票0]
用户[2]的抢票结果为 true[票1]
用户[1]的抢票结果为 true[票2]
用户[18]的抢票结果为 true[票3]
用户[4]的抢票结果为 true[票4]
/**
**票仓[[票5, 票6, 票7, 票8, 票9]]
**增加了5张票
**/
用户[20]的抢票结果为 true[票5]
用户[6]的抢票结果为 true[票6]
用户[8]的抢票结果为 true[票7]
用户[10]的抢票结果为 true[票8]
用户[12]的抢票结果为 true[票9]
/**
**票仓[[票10, 票11, 票12, 票13, 票14]]
**增加了5张票
**/
用户[14]的抢票结果为 true[票10]
用户[16]的抢票结果为 true[票11]
用户[5]的抢票结果为 true[票12]
用户[3]的抢票结果为 true[票13]
用户[7]的抢票结果为 true[票14]
/**
**票仓[[票15, 票16, 票17, 票18, 票19]]
**增加了5张票
**/
用户[9]的抢票结果为 true[票15]
用户[11]的抢票结果为 true[票16]
用户[13]的抢票结果为 true[票17]
用户[15]的抢票结果为 true[票18]
用户[17]的抢票结果为 true[票19]
/**
**票仓[[票20]]
**增加了1张票
**/
都抢完票了 余票 : [1张]