文章目录

• 1.3 同步代码块解决数据安全问题1.4 同步方法解决数据安全问题1.6 线程同步——死锁问题

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 卖票案例的问题

那我们来汇总汇总到底出现了什么问题：

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 什么情况下会产生死锁

1. 资源有限：
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被锁住了，嘎，也完了。这就是先帝创业未半而中道被锁的故事

原文链接：https://blog.csdn.net/weixin_45525272/article/details/125815337