【大数据】学习笔记 1 Java SE 第9章多线程 9.4 线程安全

水深无声 2024-03-22 11:44 36阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第9章 多线程
             *   *  9.4 线程安全
                 *   *  9.4.1 同一个资源问题和线程安全问题
                     *  9.4.2 尝试解决线程安全问题

![在这里插入图片描述][f13bb0bd74e84d2fb083f71a7e963b6b.png_pic_center]

#### 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);
            }
        }
    }

运行结果

![在这里插入图片描述][19c113365bf2477f8f489f2d911c618b.png_pic_center]

结果：发现卖出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);
            }
        }
    }

![在这里插入图片描述][97a6ede96f5448c2887aff6bda94df7f.png_pic_center]

结果：发现卖出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);
            }
        }
    }

![在这里插入图片描述][e691f2488638413d839e011d0044d7dc.png_pic_center]

结果：发现卖出近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);
            }
        }
    }

![在这里插入图片描述][ed3b1be9d9444422864e48dc6111f3a5.png_pic_center]

结果：发现卖出近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;
        }
    }

![在这里插入图片描述][0d8bbb308980448d946b75625213e2cd.png_pic_center]

结果：发现卖出近100张票。

问题：但是有重复票或负数票问题。

原因：线程安全问题

###### 9.4.2 尝试解决线程安全问题 ######

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制  
(synchronized)来解决。

![在这里插入图片描述][2ebe7ca648ca45109b7b9e31360d0594.png_pic_center]

根据案例简述：

窗口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);
            }
        }
    }

![在这里插入图片描述][6bc85e2154eb42d691a4c391e6c2de2f.png_pic_center]

示例二：非静态方法加锁

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);
            }
        }
    }

![在这里插入图片描述][5c0abd3da03a4d5891dc6287c12516be.png_pic_center]

示例三：同步代码块

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;
        }
    }

![在这里插入图片描述][7479319fcdbd4c5499d4e674136ffb18.png_pic_center]

[f13bb0bd74e84d2fb083f71a7e963b6b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9746d59467744868a3b7136265b3c1a2.png
[19c113365bf2477f8f489f2d911c618b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/79ca7a0684e246fcb3932b85b966acd5.png
[97a6ede96f5448c2887aff6bda94df7f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4688bb2852d645b0ae10146d7258783e.png
[e691f2488638413d839e011d0044d7dc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8304dfe187a54bf3aead2bd908f7447d.png
[ed3b1be9d9444422864e48dc6111f3a5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8595d18d6b1840669a17ee21ae5264a5.png
[0d8bbb308980448d946b75625213e2cd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2d185572eab8456faa7af8fc6897771b.png
[2ebe7ca648ca45109b7b9e31360d0594.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b1202e0a9b514a158cb44fb193beec15.png
[6bc85e2154eb42d691a4c391e6c2de2f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/73ae7f5372b648e28adf4fde69038edc.png
[5c0abd3da03a4d5891dc6287c12516be.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7f117a59f4d447bfbb34e6279f1c07a2.png
[7479319fcdbd4c5499d4e674136ffb18.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bb30ab3238ff4b3dad23cb6b7119ffdc.png