看了这个有趣的例子，你就能秒懂Java中的多线程同步了！
Posted 里奥ii
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了看了这个有趣的例子，你就能秒懂Java中的多线程同步了！相关的知识，希望对你有一定的参考价值。
写在前面
- 把技术概念通过文字的形式写下来，理清逻辑，加深认知；
- 把知识点通过系列文章的形式分段写下来，让思维进行刻意的训练；
- 把难懂的东西通过有趣的故事或者例子讲出来，让技术变得生动。
电影票的案例
单线程的例子
我们设定有一个电影院，该电影院开张不久，在入口的旁边只设立了一个售票点A，顾客看电影，需要在售票点排队依次买票，买完票后在入口处检票进入电影院观影。
上面的描述用代码来实现，可以是这样的：
1、首先建立一个电影票的类：主要的属性有票的ID,哪个放映厅，哪一排哪一列，放映的电影名称，放映时间及票价。
/**
* 通过卖票程序读懂多线程--电影票的类
*
* @author zhuhuix
* @date 2020-05-12
*/
public class Ticket
//id
private int ticketId;
//放映厅
private String room;
//行
private Integer row;
//列
private Integer col;
//电影名
private String filmName;
//价格
private BigDecimal price;
//放映时间
private LocalDateTime datetime;
private Ticket()
public Ticket(int ticketId,String room, Integer row, Integer col, String filmName, BigDecimal price, LocalDateTime datetime)
this.ticketId = ticketId;
this.room = room;
this.row = row;
this.col = col;
this.filmName = filmName;
this.price = price;
this.datetime = datetime;
public int getTicketId()
return ticketId;
public void setTicketId(int ticketId)
this.ticketId = ticketId;
public String getRoom()
return room;
public void setRoom(String room)
this.room = room;
public Integer getRow()
return row;
public void setRow(Integer row)
this.row = row;
public Integer getCol()
return col;
public void setCol(Integer col)
this.col = col;
public String getFilmName()
return filmName;
public void setFilmName(String filmName)
this.filmName = filmName;
public BigDecimal getPrice()
return price;
public void setPrice(BigDecimal price)
this.price = price;
public LocalDateTime getDatetime()
return datetime;
public void setDatetime(LocalDateTime datetime)
this.datetime = datetime;
@Override
public String toString()
return "Ticket" +
"ticketId=" + ticketId +
", room=" + room + \\ +
", row=" + row +
", col=" + col +
", filmName=" + filmName + \\ +
", price=" + price +
", datetime=" + datetime +
;
2、其次建立一个顾客的类：主要的属性有票的ID,购买的电影票；成员方法有买票。
/**
* 通过卖票程序读懂多线程--顾客类
*
* @author zhuhuix
* @date 2020-05-12
*/
public class Customer
//顾客id
private int customerId;
//购买的电影票
private Ticket ticket;
public Customer(int customerId)
this.customerId = customerId;
//顾客买票
public void buyTicket(Ticket ticket)
this.ticket = ticket;
public int getCustomerId()
return customerId;
public void setCustomerId(int customerId)
this.customerId = customerId;
public Ticket getTicket()
return ticket;
public void setTicket(Ticket ticket)
this.ticket = ticket;
@Override
public String toString()
return "Customer" +
"customerId=" + customerId +
", ticket=" + ticket.toString() +
;
3、最后写一个主程序，生成电影票的列表，设定上门观影的顾客人数，依次买票，输出电影票购买的状态。
/**
* 通过卖票程序读懂多线程--单线程程序
*
* @author zhuhuix
* @date 2020-05-12
*/
public class TicketSingle
private static final String ROOM = "中央放映厅";
private static final int ROW = 10;
private static final int COL = 20;
private static final String FILM_NAME = "战狼3";
private static final BigDecimal PRICE = BigDecimal.valueOf(30);
private static List<Ticket> tickets = new ArrayList<>();
private static final int CUSTOMER_COUNT = 250;
private static List<Customer> customers = new ArrayList<>(CUSTOMER_COUNT);
public static void main(String[] args)
//中央放映厅总共有250个座位，2020-05-12 18:00 放映战狼3，售票价格为30元
int ticketId=1;
for (int row = 1; row <= ROW; row++)
for (int col = 1; col <= COL; col++)
Ticket ticket = new Ticket(ticketId++, ROOM, row, col,
FILM_NAME, PRICE,
LocalDateTime.of(2020, 5, 10, 18, 00));
tickets.add(ticket);
Iterator<Ticket> iterator = tickets.iterator();
while (iterator.hasNext())
System.out.println(iterator.next().toString());
//顾客到售票点进行随机买票
Collections.shuffle(tickets);
int index = 1;
while (tickets.size() > 0 && index <= CUSTOMER_COUNT)
Ticket ticket = tickets.get(tickets.size() - 1);
Customer customer = new Customer(index);
customer.buyTicket(ticket);
customers.add(customer);
tickets.remove(ticket);
System.out.println(tickets.size() + "," + index);
System.out.println(index + "号顾客买到了"
+ "第" + customer.getTicket().getRow() + "行，第" + customer.getTicket().getCol() + "列的票");
index++;
try
TimeUnit.MILLISECONDS.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
System.out.println("电影票出售情况如下：");
//剩余票的状态
System.out.println("剩余票数：" + tickets.size());
Iterator<Ticket> ticketIterator = tickets.iterator();
while (ticketIterator.hasNext())
System.out.println(ticketIterator.next().toString());
//顾客购买情况
System.out.println("买到票的人数：" + customers.size());
Iterator<Customer> customerIterator = customers.iterator();
while (customerIterator.hasNext())
System.out.println(customerIterator.next().toString());
System.out.println("未买到票的人数：" +(CUSTOMER_COUNT- customers.size()));
主程序的输出情况是这样的：
从单线程转向多线程
一切井然有序，程序也运行得很好，那我们继续往 下看，由于观影顾客人数的增加，电影院对放映厅做了改造：
- 增加座位；
- 增设两个卖票窗口。
也就说原来只有一个窗口排队单通道执行的程序变了，要允许原来的售票点与新增的售票点，同时进行卖票了。
有问题的多线程的例子
我们先简单的在单线程的程序上做个多线程的改造：建立一个多线程的类，重写run方法，将顾客买票的过程移至run方法中，在主程中设立”售票点A“，”售票点B“，”售票点C“三个线程让其同时运行，对了，别忘了把ArrayList这个数据结构也改成Vector。改造后的程序是这样的：
/**
* 通过卖票程序读懂多线程--多线程
*
* @author zhuhuix
* @date 2020-05-12
*/
public class TicketThread extends Thread
private static final String ROOM = "中央放映厅";
private static final int ROW = 20;
private static final int COL = 30;
private static final String FILM_NAME = "战狼3";
private static final BigDecimal PRICE = BigDecimal.valueOf(30);
private static List<Ticket> tickets = new Vector<>();
private static final int CUSTOMER_COUNT = 800;
private static int customerId = 1;
private static List<Customer> customers = new Vector<>(CUSTOMER_COUNT);
TicketThread(String name)
super(name);
@Override
public void run()
while (tickets.size() > 0 && customerId <= CUSTOMER_COUNT)
Ticket ticket = tickets.get(tickets.size() - 1);
ticket.setWindow(Thread.currentThread().getName());
Customer customer = new Customer(customerId);
customer.buyTicket(ticket);
customers.add(customer);
tickets.remove(ticket);
System.out.println(tickets.size() + "," + customerId);
System.out.println(Thread.currentThread().getName() + ":" + customerId + "号顾客买到了"
+ "第" + customer.getTicket().getRow() + "行，第" + customer.getTicket().getCol() + "列的票");
customerId++;
try
TimeUnit.MILLISECONDS.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
public static void main(String[] args) throws InterruptedException
//中央放映厅总共有250个座位，2020-05-12 18:00 放映战狼3，售票价格为30元
int ticketId = 1;
for (int row = 1; row <= ROW; row++)
for (int col = 1; col <= COL; col++)
Ticket ticket = new Ticket(ticketId++, ROOM, row, col,
FILM_NAME, PRICE,
LocalDateTime.of(2020, 5, 10, 18, 00));
tickets.add(ticket);
Iterator<Ticket> iterator = tickets.iterator();
while (iterator.hasNext())
System.out.println(iterator.next().toString());
//顾客到售票点进行随机买票
Collections.shuffle(tickets);
TicketThread ticketThreadA = new TicketThread("售票点A");
TicketThread ticketThreadB = new TicketThread("售票点B");
TicketThread ticketThreadC = new TicketThread("售票点C");
ticketThreadA.start();
ticketThreadB.start();
ticketThreadC.start();
ticketThreadA.join();
ticketThreadB.join();
ticketThreadC.join();
System.out.println("电影票出售情况如下：");
//剩余票的状态
System.out.println("总共票数:" + ROW * COL + ",剩余票数：" + tickets.size());
Iterator<Ticket> ticketIterator = tickets.iterator();
while (ticketIterator.hasNext())
System.out.println(ticketIterator.next().toString());
//顾客购买情况
System.out.println("买到票的人数：" + customers.size());
Iterator<Customer> customerIterator = customers.iterator();
while (customerIterator.hasNext())
System.out.println(customerIterator.next().toString());
System.out.println("未买到票的人数：" + (CUSTOMER_COUNT - customers.size()));
运行一下：总共只有600张票，买到票的人有614人？那进了电影院顾客肯定得投诉。
线程同步问题
我们分析一下：
电影票总共只有600张，三个窗口同时卖这600张票，电影票是个共享的池子，在多线程术语上称为”共享资源“或”临界资源“，每个线程访问这些资源时，要保证”同步“：售票点A要卖第10排第9列的座位时，当且仅当同一时刻只有售票点A才能访问这个座位对应的电影票，也就是所谓的不能一票多卖。
那多线程如何保证同步？通过加锁！！ 加锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源。（Java知音公众号中回复“面试题聚合”，送你一份面试题宝典！）
保证线程同步的例子
为了可以简单地说明加锁可以保证多线程同步，在下面的例子中仅实现对电影票共享池进行加锁。
/**
* 通过卖票程序读懂多线程--多线程
*
* @author zhuhuix
* @date 2020-05-12
*/
public class TicketThread extends Thread
private static final String ROOM = "中央放映厅";
private static final int ROW = 20;
private static final int COL = 30;
private static final String FILM_NAME = "战狼3";
private static final BigDecimal PRICE = BigDecimal.valueOf(30);
private volatile static List<Ticket> tickets = new Vector<>();
private static final int CUSTOMER_COUNT = 800;
private static int customerId = 1;
private volatile static List<Customer> customers = new Vector<>(CUSTOMER_COUNT);
TicketThread(String name)
super(name);
@Override
public void run()
while (tickets.size() > 0 && customerId <= CUSTOMER_COUNT)
synchronized (TicketThread.class)
//线程内两次判断，防止tickets 数组溢出
if (tickets.size()>0)
Ticket ticket = tickets.get(tickets.size() - 1);
ticket.setWindow(Thread.currentThread().getName());
Customer customer = new Customer(customerId);
customer.buyTicket(ticket);
customers.add(customer);
tickets.remove(ticket);
System.out.println(tickets.size() + "," + customerId);
System.out.println(Thread.currentThread().getName() + ":" + customerId + "号顾客买到了"
+ "第" + customer.getTicket().getRow() + "行，第" + customer.getTicket().getCol() + "列的票");
customerId++;
try
TimeUnit.MILLISECONDS.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
public static void main(String[] args) throws InterruptedException
//中央放映厅总共有250个座位，2020-05-12 18:00 放映战狼3，售票价格为30元
int ticketId = 1;
for (int row = 1; row <= ROW; row++)
for (int col = 1; col <= COL; col++)
Ticket ticket = new Ticket(ticketId++, ROOM, row, col,
FILM_NAME, PRICE,
LocalDateTime.of(2020, 5, 10, 18, 00));
tickets.add(ticket);
Iterator<Ticket> iterator = tickets.iterator();
while (iterator.hasNext())
System.out.println(iterator.next().toString());
//顾客到售票点进行随机买票
Collections.shuffle(tickets);
TicketThread ticketThreadA = new TicketThread("售票点A");
TicketThread ticketThreadB = new TicketThread("售票点B");
TicketThread ticketThreadC = new TicketThread("售票点C");
ticketThreadA.start();
ticketThreadB.start();
ticketThreadC.start();
ticketThreadA.join();
ticketThreadB.join();
ticketThreadC.join();
System.out.println("电影票出售情况如下：");
//剩余票的状态
System.out.println("总共票数:" + ROW * COL + ",剩余票数：" + tickets.size());
Iterator<Ticket> ticketIterator = tickets.iterator();
while (ticketIterator.hasNext())
System.out.println(ticketIterator.next().toString());
//顾客购买情况
System.out.println("买到票的人数：" + customers.size());
Iterator<Customer> customerIterator = customers.iterator();
while (customerIterator.hasNext())
System.out.println(customerIterator.next().toString());
System.out.println("未买到票的人数：" + (CUSTOMER_COUNT - customers.size()));
运行情况如下：
票不超卖了：
每个窗口也实现了同步并发卖票：
同步的代码主要的改变来自于：
1、将卖票的过程用synchronized修饰，实现锁的互斥，具体可以参考java多线程：
synchronized (TicketThread.class)
Ticket ticket = tickets.get(tickets.size() - 1);
ticket.setWindow(Thread.currentThread().getName());
Customer customer = new Customer(customerId);
customer.buyTicket(ticket);
customers.add(customer);
tickets.remove(ticket);
System.out.println(tickets.size() + "," + customerId);
System.out.println(Thread.currentThread().getName() + ":" + customerId + "号顾客买到了"
+ "第" + customer.getTicket().getRow() + "行，第" + customer.getTicket().getCol() + "列的票");
customerId++;
try
TimeUnit.MILLISECONDS.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
2、将共享资源用volatile 修饰，实现线程访问的可视化，具体可以参考上文链接。
private volatile static List<Ticket> tickets = new Vector<>();
private volatile static List<Customer> customers = new Vector<>(CUSTOMER_COUNT);
写在最后
程序所有的表达，归根到底都是逻辑问题。而逻辑的核心是清晰高效地思考问题。对于多线程的理解，大家一定要起手来写一些例程，融汇贯通才能体会到真谛，才能真正应用到工作实践中去。
原作者：智慧zhuhuix
以上是关于看了这个有趣的例子，你就能秒懂Java中的多线程同步了！的主要内容，如果未能解决你的问题，请参考以下文章