Java多线程：线程同步详解
Posted 流楚丶格念
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java多线程：线程同步详解相关的知识，希望对你有一定的参考价值。
文章目录
Java线程同步
1.1 经典的卖票问题
代码需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
小A说灰常简单，马上设计了一个实现步骤：
- 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
- 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票卖没了，线程停止
- 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象
- 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
- 启动线程
好，小A灰常激动，他马上实现了所想的代码：
public class SellTicket implements Runnable
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run()
while (true)
if(ticket <= 0)
//卖完了
break;
else
try
Thread.sleep(100);
catch (InterruptedException e)
e.printStackTrace();
ticket--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
public class SellTicketDemo
public static void main(String[] args)
//创建SellTicket类的对象
SellTicket st = new SellTicket();
//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();
小A的运行结果是这样的：
结果你就发现：
电影院要是小A开的，卖个票这不得打起来，当黄牛看到自己手上的-2好票时，他肯定也会怀疑人生。
1.2 卖票案例的问题
那我们来汇总汇总到底出现了什么问题：
- 相同的票出现了多次
- 出现了负数的票
那么问题产生原因是什么呢？
- 线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题
那么我们要怎么解决这个问题呢？
这就要用到Java的同步代码块，相信点进来的小伙伴们肯定是知道同步和异步是什么的，要不然也不会好奇点进来，所以这里就不在赘述操作系统的知识了
不清除的小伙伴可以参考我转载的另一篇博文：https://blog.csdn.net/weixin_45525272/article/details/125815446
1.3 同步代码块解决数据安全问题
要解决数据安全问题，我们先来看看数据安全问题出现的条件：
- 首先是多线程环境
- 要有共享数据
- 要有多条语句操作共享数据
那么我们如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
怎么实现这种思想呢?
- 重点是要创建一个环境
- 我们可以把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行就行了
1.3.1 Java同步代码块
Java提供了同步代码块的方式来解决改实现
同步代码块格式：
synchronized(任意对象)
多条语句操作共享数据的代码
说明：synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
1.3.2 同步的好处和弊端
-
好处：解决了多线程的数据安全问题
-
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
1.3.2 代码示例
根据Java提供的方法，我们可以向导用synchronized包裹卖票操作即可
synchronized (obj)
窗口买票操作
这里的obj是任意对象，直接声明一个Object对象即可，例如：
private Object obj = new Object();
完整代码如下：
public class SellTicket implements Runnable
private int tickets = 100;
private Object obj = new Object();
@Override
public void run()
while (true)
synchronized (obj) // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
//t1进来后，就会把这段代码给锁起来
if (tickets > 0)
try
Thread.sleep(100);
//t1休息100毫秒
catch (InterruptedException e)
e.printStackTrace();
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
//t1出来了，这段代码的锁就被释放了
public class SellTicketDemo
public static void main(String[] args)
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
运行结果如下：
可以看到没有问题，黄牛都笑了
1.4 同步方法解决数据安全问题
除了同步代码块，Java也提供了同步方法来解决数据安全问题。
同步方法的格式：同步方法：就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数)
方法体；
那么有彤学就会有疑问了，同步方法的锁对象是什么呢?
答案也显而易见：就是this对象
那么静态的方法能进行同步么？那可真是裤裆里冒烟——当然了
1.4.1 静态同步方法
同步静态方法：就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数)
方法体；
那么同步静态方法的锁对象是什么呢?
答案就是：类名.class
1.4.2 代码示例
还是刚才的卖票案例，我们将其改造为同步方法：
完整代码如下：
package com.test;
public class MyTicket implements Runnable
private static int ticketCount = 100;
@Override
public void run()
while(true)
if("窗口一".equals(Thread.currentThread().getName()))
// 同步方法
boolean result = synchronizedMthod();
if(result)
break;
if("窗口二".equals(Thread.currentThread().getName()))
// 同步方法
boolean result = synchronizedMthod();
if (result)
break;
private static synchronized boolean synchronizedMthod()
if(ticketCount == 0)
return true;
else
try
Thread.sleep(100);
catch (InterruptedException e)
e.printStackTrace();
ticketCount--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
return false;
class Demo
public static void main(String[] args)
MyTicket mr = new MyTicket();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("窗口一");
t2.setName("窗口二");
t1.start();
t2.start();
运行结果：
1.5 Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock构造方法
| 方法名 | 说明 |
|---|---|
| ReentrantLock() | 创建一个ReentrantLock的实例 |
加锁解锁方法
| 方法名 | 说明 |
|---|---|
| void lock() | 获得锁 |
| void unlock() | 释放锁 |
例如我们要先创建一个ReentrantLock实例：
private ReentrantLock lock = new ReentrantLock();
在实现业务时候加锁，业务完成时解决即可，如下代码
try
lock.lock();
实现业务
catch (InterruptedException e)
e.printStackTrace();
finally
lock.unlock();
那我们对卖票案例进行改造
1.5.1 代码示例
public class Ticket implements Runnable
//票的数量
private int ticket = 100;
private Object obj = new Object();
private ReentrantLock lock = new ReentrantLock();
@Override
public void run()
while (true)
try
lock.lock();
if (ticket <= 0)
//卖完了
break;
else
Thread.sleep(100);
ticket--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
catch (InterruptedException e)
e.printStackTrace();
finally
lock.unlock();
public class Demo
public static void main(String[] args)
Ticket ticket = new Ticket();
// 需要保证用的是同一把锁，所以用的都是一个Ticket对象
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
运行结果如下：
1.6 线程同步——死锁问题
1.6.1 概述
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
1.6.2 什么情况下会产生死锁
- 资源有限：
- 同步嵌套：A调用B，B调用A
1.6.3 代码示例
public class Demo
public static void main(String[] args)
Object objA = new Object();
Object objB = new Object();
new Thread(()->
while(true)
synchronized (objA)
//线程一
synchronized (objB)
System.out.println("小莫同学正在走路");
).start();
new Thread(()->
while(true)
synchronized (objB)
//线程二
synchronized (objA)
System.out.println("小薇同学正在走路");
).start();
运行上面代码，我们会发现，小莫走着走着，诶？走不动了，而小薇呢，在原地瑟瑟发抖，一步没有向前走。
这是为什么呢？
可以参考一下我画的原理分析图：
首先是小莫走两步，然后有一次她刚走一半把A锁上了，然后此时此刻，小薇也想走啊，不能老搁原地待着啊，人都是想进步的啊，她冲，走一半把B也锁上了，此时呢小莫再想走走不了了，用的一个锁啊，B被锁住了，嘎，完了，走不了了，小薇呢，再走也走不了了，A被锁住了，嘎，也完了。这就是先帝创业未半而中道被锁的故事
以上是关于Java多线程：线程同步详解的主要内容，如果未能解决你的问题，请参考以下文章