【Java】—— 多线程：线程安全问题及解决

已于 2024-09-21 22:01:07 修改
阅读量997 收藏 19
点赞数 19
分类专栏： JAVA 文章标签： java 开发语言
于 2024-09-21 22:00:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63106307/article/details/142421849
版权

目录

5. 线程安全问题及解决

5.1 同一个资源问题和线程安全问题

5.1.1 局部变量不能共享

5.1.2 不同对象的实例变量不共享

5.1.3 静态变量是共享的

5.1.4 同一个对象的实例变量共享

5.2 同步机制解决线程安全问题

5.2.1 同步机制解决线程安全问题的原理

5.2.2 同步代码块和同步方法

5.2.3 同步锁机制

5.2.4 synchronized的锁是什么

方法一：同步代码块 

方法二：同步方法

练习

5. 线程安全问题及解决

        当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题。但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。

举例：

5.1 同一个资源问题和线程安全问题

案例：

        火车站要卖票，我们模拟火车站的卖票过程。因为疫情期间，本次列车的座位共100个（即，只能出售100张火车票）。我们来模拟车站的售票窗口，实现多个窗口同时售票的过程。注意：不能出现错票、重票。

   

5.1.1 局部变量不能共享

示例代码：

class Window extends Thread {
    public void run() {
        int ticket = 100;
        while (ticket > 0) {
            System.out.println(getName() + "卖出一张票，票号:" + ticket);
            ticket--;
        }
    }
}

public class SaleTicketDemo1 {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

结果：发现卖出300张票。

问题：局部变量是每次调用方法都是独立的，那么每个线程的run()的ticket是独立的，不是共享数据。

5.1.2 不同对象的实例变量不共享
class TicketWindow extends Thread {
    private int ticket = 100;

    public void run() {
        while (ticket > 0) {
            System.out.println(getName() + "卖出一张票，票号:" + ticket);
            ticket--;
        }
    }
}

public class SaleTicketDemo2 {
    public static void main(String[] args) {
        TicketWindow w1 = new TicketWindow();
        TicketWindow w2 = new TicketWindow();
        TicketWindow w3 = new TicketWindow();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

结果：发现卖出300张票。

问题：不同的实例对象的实例变量是独立的。

5.1.3 静态变量是共享的

示例代码：

class TicketSaleThread extends Thread {
    private static int ticket = 100;

    public void run() {
        while (ticket > 0) {
            try {
                Thread.sleep(10);//加入这个，使得问题暴露的更明显
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + "卖出一张票，票号:" + ticket);
            ticket--;
        }
    }
}

public class SaleTicketDemo3 {
    public static void main(String[] args) {
        TicketSaleThread t1 = new TicketSaleThread();
        TicketSaleThread t2 = new TicketSaleThread();
        TicketSaleThread t3 = new TicketSaleThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

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

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

原因：线程安全问题

问题2：如果要考虑有两场电影，各卖100张票等

原因：TicketThread类的静态变量，是所有TicketThread类的对象共享

5.1.4 同一个对象的实例变量共享

示例代码：多个Thread线程使用同一个Runnable对象

package notsafe;

/**
 * ClassName:IntelliJ IDEA
 * Description:
 *      使用实现Runnable接口的方式实现卖票。。出现线程安全问题
 *
 *      火车站要卖票，我们模拟火车站的卖票过程。因为疫情期间，本次列车的座位共100个（即，只能出售100张火车票）。
 *      我们来模拟车站的售票窗口，实现多个窗口同时售票的过程。注意：不能出现错票、重票。
 * @Author zyjstart
 * @Create:2024/9/21 17:23
 */
class SaleTicket implements Runnable{
    int ticket = 100;   // 此变量放在此处被共享，不可放在方法里
    @Override
    public void run() {

        while (true){

            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}


public class WindowTest {
    public static void main(String[] args) {
        SaleTicket s = new SaleTicket();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        Thread t3 = new Thread(s);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

运行如下：

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

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

原因：线程安全问题

5.2 同步机制解决线程安全问题

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

根据案例简述：

        窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

        为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。

5.2.1 同步机制解决线程安全问题的原理

        同步机制的原理，其实就相当于给某段代码加“锁”，任何线程想要执行这段代码，都要先获得“锁”，我们称它为同步锁。因为Java对象在堆中的数据分为分为对象头、实例变量、空白的填充。而对象头中包含：

  • Mark Word：记录了和当前对象有关的GC、锁标记等信息。

  • 指向类的指针：每一个对象需要记录它是由哪个类创建出来的。

  • 数组长度（只有数组对象才有）

        哪个线程获得了“同步锁”对象之后，”同步锁“对象就会记录这个线程的ID，这样其他线程就只能等待了，除非这个线程”释放“了锁对象，其他线程才能重新获得/占用”同步锁“对象。

5.2.2 同步代码块和同步方法

同步代码块：synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。 格式:

 

同步方法：synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。
 

 

5.2.3 同步锁机制
 

        在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
 

5.2.4 synchronized的锁是什么
 

        同步锁对象可以是任意类型，但是必须保证竞争“同一个共享资源”的多个线程必须使用同一个“同步锁对象”。
 

对于同步代码块来说，同步锁对象是由程序员手动指定的（很多时候也是指定为this或类名.class），但是对于同步方法来说，同步锁对象只能是默认的：
 

  •  
    静态方法：当前类的Class对象（类名.class）
     
  •  
    非静态方法：this
     
 

 

方法一：同步代码块 
 

使用同步代码块方法    通过修改上述案例进行演示：
 

package runnablesafe;

/**
 * ClassName:IntelliJ IDEA
 * Description:
 *      使用实现Runnable接口的方式实现卖票。。出现线程安全问题
 *      使用同步代码块解决上述卖票中的线程安全问题
 *
 *      火车站要卖票，我们模拟火车站的卖票过程。因为疫情期间，本次列车的座位共100个（即，只能出售100张火车票）。
 *      我们来模拟车站的售票窗口，实现多个窗口同时售票的过程。注意：不能出现错票、重票。
 * @Author zyjstart
 * @Create:2024/9/21 17:23
 */
class SaleTicket implements Runnable{
    int ticket = 100;   // 此变量放在此处被共享，不可放在方法里
    Object obj = new Object();
    @Override
    public void run() {

        while (true){

            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (obj){ //obj必须是唯一的
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }

        }
    }
}


public class WindowTest {
    public static void main(String[] args) {
        SaleTicket s = new SaleTicket();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        Thread t3 = new Thread(s);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

 

演示如下：
 

 

方法二：同步方法
 

package runnablesafe;

/**
 * ClassName:IntelliJ IDEA
 * Description:
 *      使用实现Runnable接口的方式实现卖票。。出现线程安全问题
 *      使用同步方法解决上述卖票中的线程安全问题
 *
 *      火车站要卖票，我们模拟火车站的卖票过程。因为疫情期间，本次列车的座位共100个（即，只能出售100张火车票）。
 *      我们来模拟车站的售票窗口，实现多个窗口同时售票的过程。注意：不能出现错票、重票。
 * @Author zyjstart
 * @Create:2024/9/21 17:23
 */
class SaleTicket1 implements Runnable{
    int ticket = 100;   // 此变量放在此处被共享，不可放在方法里
    boolean isFlag = true;
    @Override
    public void run() {

        while (isFlag){
            show();

        }
    }

    public synchronized void show(){    //此时的同步监视器是：this，是唯一的
        if (ticket>0){
            System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
            ticket--;
        }else {
            isFlag = false;
        }
    }
}


public class WindowTest1 {
    public static void main(String[] args) {
        SaleTicket1 s = new SaleTicket1();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        Thread t3 = new Thread(s);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

 

练习
 

 

银行有一个账户。 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
 

问题：该程序是否有安全问题，如果有，如何解决？
 

【提示】
 

1，明确哪些代码是多线程运行代码，须写入run()方法
 

2，明确什么是共享数据。
 

3，明确多线程运行代码中哪些语句是操作共享数据的。
 

【拓展问题】可否实现两个储户交替存钱的操作
 

package exer1;

/**
 * ClassName:IntelliJ IDEA
 * Description:
 *
 * @Author zyjstart
 * @Create:2024/9/21 21:32
 */

class cun implements Runnable{
    int target = 0;
    @Override
    public void run() {
        while (true){
            synchronized (this){
                if (target<3000){
                    target+=1000;
                    System.out.println(Thread.currentThread().getName() + "存入1000");
                    System.out.println("账户余额为：" + target);

                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else {
                    break;
                }
            }
        }


    }
}
public class Test {
    public static void main(String[] args) {
        cun c = new cun();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);

        t1.setName("账户1");
        t2.setName("账户2");

        t1.start();
        t2.start();



    }
}

 

运行结果如下：
 

 

 

 


                

        

    

  



    



            

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值