【大数据】学习笔记
1 Java SE
第9章 多线程
9.4 线程安全
当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。
我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个
(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
9.4.1 同一个资源问题和线程安全问题
【1】局部变量不能共享
package com.dingjiaxiong.unsafe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo1
* @Author: Ding Jiaxiong
* @Date:2023/4/27 15:59
*/
public class SaleTicketDemo1 {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread {
public void run() {
int total = 100;
while (total > 0) {
System.out.println(getName() + "卖出一张票，剩余:" + --total);
}
}
}
运行结果
结果：发现卖出300张票。
问题：局部变量是每次调用方法都是独立的，那么每个线程的run()的total是独立的，不是共享数据。
【2】不同对象的实例变量不共享
package com.dingjiaxiong.unsafe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo2
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:01
*/
public class SaleTicketDemo2 {
public static void main(String[] args) {
TicketSale t1 = new TicketSale();
TicketSale t2 = new TicketSale();
TicketSale t3 = new TicketSale();
t1.start();
t2.start();
t3.start();
}
}
class TicketSale extends Thread {
private int total = 100;
public void run() {
while (total > 0) {
System.out.println(getName() + "卖出一张票，剩余:" + --total);
}
}
}
结果：发现卖出300张票。
问题：不同的实例对象的实例变量是独立的。
【3】静态变量是共享的
示例代码：
package com.dingjiaxiong.unsafe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo3
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:02
*/
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketSaleThread t1 = new TicketSaleThread();
TicketSaleThread t2 = new TicketSaleThread();
TicketSaleThread t3 = new TicketSaleThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleThread extends Thread {
private static int total = 100;
public void run() {
while (total > 0) {
try {
Thread.sleep(10);//加入这个，使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "卖出一张票，剩余:" + --total);
}
}
}
结果：发现卖出近100张票。
问题（1）：但是有重复票或负数票问题。
原因：线程安全问题
问题（2）：如果要考虑有两场电影，各卖100张票等
原因：TicketThread类的静态变量，是所有TicketThread类的对象共享
【4】同一个对象的实例变量共享
示例代码：多个Thread线程使用同一个Runnable对象
package com.dingjiaxiong.unsafe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo4
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:03
*/
public class SaleTicketDemo4 {
public static void main(String[] args) {
TicketSaleRunnable tr = new TicketSaleRunnable();
Thread t1 = new Thread(tr, "窗口一");
Thread t2 = new Thread(tr, "窗口二");
Thread t3 = new Thread(tr, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleRunnable implements Runnable {
private int total = 100;
public void run() {
while (total > 0) {
try {
Thread.sleep(10);//加入这个，使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
}
}
}
结果：发现卖出近100张票。
问题：但是有重复票或负数票问题。
原因：线程安全问题
【5】抽取资源类，共享同一个资源对象
示例代码：
package com.dingjiaxiong.unsafe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo5
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:04
*/
public class SaleTicketDemo5 {
public static void main(String[] args) {
//2、创建资源对象
Ticket ticket = new Ticket();
//3、启动多个线程操作资源类的对象
Thread t1 = new Thread("窗口一") {
public void run() {
while (true) {
ticket.sale();
}
}
};
Thread t2 = new Thread("窗口二") {
public void run() {
while (true) {
ticket.sale();
}
}
};
Thread t3 = new Thread(new Runnable() {
public void run() {
ticket.sale();
}
}, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
//1、编写资源类
class Ticket {
private int total = 100;
public void sale() {
if (total > 0) {
try {
Thread.sleep(10);//加入这个，使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
} else {
throw new RuntimeException("没有票了");
}
}
public int getTotal() {
return total;
}
}
结果：发现卖出近100张票。
问题：但是有重复票或负数票问题。
原因：线程安全问题
9.4.2 尝试解决线程安全问题
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制
(synchronized)来解决。
根据案例简述：
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。
【1】同步机制的原理
同步解决线程安全的原理：
同步机制的原理，其实就相当于给某段代码加“锁”，任何线程想要执行这段代码，都要先获得“锁”，我们称为它同步锁。因为Java对象在堆中的数据分为分为对象头、实例变量、空白的填充。而对象头中包含：
- Mark Word：记录了和当前对象有关的GC、锁标记等信息。
- 指向类的指针：每一个对象需要记录它是由哪个类创建出来的。
- 数组长度（只有数组对象才有）
哪个线程获得了“同步锁”对象之后，”同步锁“对象就会记录这个线程的ID，这样其他线程就只能等待了，除非这个线程”释放“了锁对象，其他线程才能重新获得/占用”同步锁“对象。
【2】同步代码块和同步方法
同步方法：synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步代码块：synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
}
【3】同步锁对象的选择
同步锁对象可以是任意类型，但是必须保证竞争“同一个共享资源”的多个线程必须使用同一个“同步锁对象”。
对于同步代码块来说，同步锁对象是由程序员手动指定的，但是对于同步方法来说，同步锁对象只能是默认的，
-
静态方法：当前类的Class对象
-
非静态方法：this
【4】同步代码的范围选择
锁的范围太小：不能解决安全问题
锁的范围太大：因为一旦某个线程抢到锁，其他线程就只能等待，所以范围太大，效率会降低，不能合理利用CPU资源。
【5】代码演示
示例一：静态方法加锁
package com.dingjiaxiong.safe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo3
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:07
*/
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketSaleThread t1 = new TicketSaleThread();
TicketSaleThread t2 = new TicketSaleThread();
TicketSaleThread t3 = new TicketSaleThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleThread extends Thread {
private static int total = 100;
public void run() {
//直接锁这里，肯定不行，会导致，只有一个窗口卖票
while (total > 0) {
saleOneTicket();
}
}
public synchronized static void saleOneTicket() {
//锁对象是TicketSaleThread类的Class对象，而一个类的Class对象在内存中肯定只有一个
if (total > 0) {
//不加条件，相当于条件判断没有进入锁管控，线程安全问题就没有解决
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
}
}
}
示例二：非静态方法加锁
package com.dingjiaxiong.safe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo4
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:07
*/
public class SaleTicketDemo4 {
public static void main(String[] args) {
TicketSaleRunnable tr = new TicketSaleRunnable();
Thread t1 = new Thread(tr, "窗口一");
Thread t2 = new Thread(tr, "窗口二");
Thread t3 = new Thread(tr, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleRunnable implements Runnable {
private int total = 1000;
public void run() {
//直接锁这里，肯定不行，会导致，只有一个窗口卖票
while (total > 0) {
saleOneTicket();
}
}
public synchronized void saleOneTicket() {
//锁对象是this，这里就是TicketSaleRunnable对象，因为上面3个线程使用同一个TicketSaleRunnable对象，所以可以
if (total > 0) {
//不加条件，相当于条件判断没有进入锁管控，线程安全问题就没有解决
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
}
}
}
示例三：同步代码块
package com.dingjiaxiong.safe;
/**
* @Projectname: BigDataStudy
* @Classname: SaleTicketDemo5
* @Author: Ding Jiaxiong
* @Date:2023/4/27 16:08
*/
public class SaleTicketDemo5 {
public static void main(String[] args) {
//2、创建资源对象
Ticket ticket = new Ticket();
//3、启动多个线程操作资源类的对象
Thread t1 = new Thread("窗口一") {
public void run() {
//不能给run()直接假设，因为t1,t2,t3的三个run方法分别属于三个Thread类对象，
// run方法是非静态方法，那么锁对象默认选this，那么锁对象根本不是同一个
while (true) {
synchronized (ticket) {
ticket.sale();
}
}
}
};
Thread t2 = new Thread("窗口二") {
public void run() {
while (true) {
synchronized (ticket) {
ticket.sale();
}
}
}
};
Thread t3 = new Thread(new Runnable() {
public void run() {
synchronized (ticket) {
ticket.sale();
}
}
}, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
//1、编写资源类
class Ticket {
private int total = 1000;
public void sale() {
//也可以直接给这个方法加锁，锁对象是this，这里就是Ticket对象
if (total > 0) {
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
} else {
throw new RuntimeException("没有票了");
}
}
public int getTotal() {
return total;
}
}
