(十)java共享数据、内置锁、死锁

已于 2023-08-17 11:27:28 修改
阅读量45 收藏
点赞数
分类专栏： Step1 文章标签： java 开发语言
于 2023-07-28 20:46:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55439500/article/details/131986562
版权

目录

1. 多窗口买票

在这里插入图片描述

多窗口售票问题
问题：剩余票数为负数
public class test1 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        ticket.setCount(100);
        TicketTask ticketTask = new TicketTask(ticket);
        Thread t1 = new Thread(ticketTask,"窗口1");
        Thread t2 = new Thread(ticketTask,"窗口2");
        Thread t3 = new Thread(ticketTask,"窗口3");
        Thread t4 = new Thread(ticketTask,"窗口4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();//同时启动四个线程
    }
}
public class Ticket {
    private int count;
    public void setCount(int count) {
        this.count = count;
    }
    public int  checkCount(){
        return this.count;
    }
    public void  outTicket(){
        this.count--;
    }
}
public class TicketTask implements Runnable {
    private Ticket ticket;
    public TicketTask() {
    }
    public TicketTask(Ticket ticket) {
        this.ticket = ticket;
    }
    @Override
    public void run() {
        while (true) {
            if (ticket.checkCount() <= 0)
                break;
            try {
                Thread.sleep(550);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket.outTicket();
            System.out.println(Thread.currentThread().getName() + "\t 剩余票数：" + ticket.checkCount());
        }
    }
}
结果为：
窗口3	 剩余票数：7
窗口2	 剩余票数：4
窗口1	 剩余票数：3
窗口3	 剩余票数：2
窗口4	 剩余票数：4
窗口4	 剩余票数：1
窗口3	 剩余票数：-2
窗口1	 剩余票数：-1
窗口2	 剩余票数：-1

理想状态是当票零时，停止出售，买票任务不安全

  • 超卖问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
  • 解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

2. 临界区代码块

临界区代码段是每个线程中访问临界资源的那段代码，多个线程必须互斥地对临界区资源进行访问。线程进入临界区代码段之前，必须在进入区申请资源，申请成功之后进行临界区代码段，执行完成之后释放资源。临界区代码段（Critical Section）的进入和退出即：多个线程同时访问的代码块，比如上面的例子：

		while (true) {
            if (ticket.checkCount() <= 0)
                break;
            try {
                Thread.sleep(550);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket.outTicket();
            System.out.println(Thread.currentThread().getName() + "\t 剩余票数：" + ticket.checkCount());
        }

3. 共享数据

临界区代码块中，多个线程共享访问的堆里面的数据

  • 一般的共享数据为堆中的数据
  • 加锁通常是给共享数据加锁

4. synchronized内置锁

请添加图片描述

5. synchronized语法

5.1 代码块

synchronized (共享对象(plus,ticket)) {//临界区代码块
    对共对象的访问（plus）(ticket)
}

比如售票买票系统

多窗口售票问题
使用synchronized上锁
public class test1 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        ticket.setCount(100);
        TicketTask ticketTask = new TicketTask(ticket);
        Thread t1 = new Thread(ticketTask,"窗口1");
        Thread t2 = new Thread(ticketTask,"窗口2");
        Thread t3 = new Thread(ticketTask,"窗口3");
        Thread t4 = new Thread(ticketTask,"窗口4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

public class Ticket {
    private int count;
    public void setCount(int count) {
        this.count = count;
    }
    public int  checkCount(){
        return this.count;
    }
    public void  outTicket(){
        this.count--;
    }
}

public class TicketTask implements Runnable {
    private Ticket ticket;
    public TicketTask() {
    }
    public TicketTask(Ticket ticket) {
        this.ticket = ticket;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (this) {//对代码块进行上锁，锁为:该对象变量名
                if (ticket.checkCount() <= 0)
                    break;
                try {
                    Thread.sleep(550);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket.outTicket();
                System.out.println(Thread.currentThread().getName() + "\t 剩余票数：" + ticket.checkCount());
            }
        }
    }
}

5.2 实例方法上锁

相当于synchronized(this)
比如对汽车的保养过程

汽车的打蜡抛光(非静态)
public class SynDemo1 {
    public static void main(String[] args) {
        Car a = new Car();
        Thread1 t1 = new Thread1(a);
        Thread2 t2 = new Thread2(a);
        t1.start();
        t2.start();
    }
}
class Thread1 extends Thread {
    private Car a;
    public Thread1(Car a) {
        this.a = a;
    }
    public void run() {
        a.fun1();
    }
}
class Thread2 extends Thread {
    private Car a;
    public Thread2(Car a) {
        this.a = a;
    }
    public void run() {
        a.fun2();
    }
}
class Car {
    public void fun1() {
        synchronized (this) {
            System.out.println("开始打蜡");
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("打蜡结束");
        }
    }
    public void fun2() {
        synchronized (this) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("开始抛光");
                System.out.println("抛光结束");
            }
        }
    }
}
开始打蜡
打蜡结束
开始抛光
抛光结束

5.3 静态方法上锁

相当于synchronized(class)，

public class SynDemo1 {
    public static void main(String[] args) {
        Car a = new Car();
        Thread t1 = new Thread1(a);
        Thread t2 = new Thread2(a);
        t1.start();
        t2.start();
    }
}
class Thread1 extends Thread {
    private Car a;
    public Thread1(Car a) {
        this.a = a;
    }
    public void run() {
        a.fun1();
    }
}
class Thread2 extends Thread {
    private Car a;
    public Thread2(Car a) {
        this.a = a;
    }
    public void run() {
        a.fun2();
    }
}
class Car {
    public synchronized static void fun1() {
        System.out.println("开始打蜡");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打蜡结束");
    }
    public static void fun2() {
        synchronized (Car.class) {
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("开始抛光");
            System.out.println("抛光结束");
        }
    }
}

6. 必须有相同的锁

public class Test1 {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();
    }
}
public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (String.class) {
                System.out.println("a");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("b");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (Integer.class) {
                System.out.println("1");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("2");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
否则无效

7. 死锁

Synchronized嵌套使用时，比如张三在A电话亭想去B电话亭，李四在B电话亭想去A电话亭，这时会发生死锁。
a线程锁定一个资源，同时想获取b线程的资源，b线程锁定一个资源，同时想获取a线程的资源。
此时会发生死锁

public class DeadLock {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (String.class) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized (Integer.class) {
                    }
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (Integer.class) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized (String.class) {
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

8. CountDownLatch

juc的公共锁

  • 构造函数new CountDownLatch(10)授权数量
  • countDown()授权数量-1
  • awit()执行后线程进入阻塞状态，直到授权数量=0；
public class Plus {
    private int count;
    public int getCount() {
        return count;
    }
    public void selfPlus(){
        count++;
    }
}
public class MyTask implements Runnable {
    private Plus plus;
    public MyTask() {
    }
    public MyTask(Plus plus) {
        this.plus = plus;
    }
    CountDownLatch countDownLatch = new CountDownLatch(4);
    @Override
    public void run() {
        synchronized (plus) {
            for (int i = 0; i < 100000000; i++) {
                plus.selfPlus();
            }
            countDownLatch.countDown();
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Plus plus = new Plus();
        MyTask myTask = new MyTask(plus);
        for (int i = 0; i < 4; i++) {
            new Thread(myTask).start();
        }
        myTask.countDownLatch.await();
        System.out.println("真实值 = " + plus.getCount());
    }
}
实际值为：400000000
ANONYMOUS%
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java死锁
weixin_43442127的博客
12-30 886
Java死锁相关知识点
java死锁源码java死锁源码
11-05
java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁源码java死锁...
JAVA篇_线程锁synchronized、lock与死锁
qq_45878219的博客
08-09 3985
在分布式开发中，锁是线程控制的重要途径。Java为此也提供了2种锁机制，synchronized和lock。 区别： 1、lock是一个接口，而synchronized是java的一个关键字。 2、synchronized在发生异常时会自动释放占有的锁，因此不会出现死锁；而lock发生异常时，不会主动释放占有的锁，必须手动来释放锁，可能引起死锁的发生，Java中每一个对象都可以作为锁，这是synchronized实现同步的基础： 3、Lock是显示锁（需要手动开关），synchronized始于隐式
Java中的锁机制 -- 乐观锁、悲观锁、自旋锁、可重入锁、读写锁、公平锁、非公平锁、共享锁、独占锁、重量级锁、轻量级锁、偏向锁、分段锁、互斥锁、同步锁、死锁、锁粗化、锁消除
天行健 君子以自强不息，地势坤 君子以厚德载物。
04-12 2163
乐观锁是一种乐观思想，假定当前环境是读多写少，遇到并发写的概率比较低，读数据时认为别的线程不会正在进行修改（所以没有上锁）。写数据时，判断当前与期望 值是否相同，如果相同则进行更新（更新期间加锁，保证是原子性的）。Java中的乐观锁：CAS（Compare And Set），比较并替换，比较当前值（主内存中的值），与预期值（当前线程中的值，主内存中值的一份拷贝）是否一样，一样则更新，否则继续进行CAS操作。如上图所示，乐观锁可以同时进行读操作，读的时候其他线程不能进行写操作。悲观锁是一种悲观思想，即认为写多
Java中的锁
njitzyd
05-04 1494
Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文主要介绍了Java中的锁机制以及常用的锁的实现，以帮助工作中更好的运用。锁是jvm内置的锁，不同于锁。关键字可以修饰方法，也可以修饰代码块。关键字修饰方法时可以修饰静态方法，也可以修饰非静态方法；关键字可以修饰代码块。值得注意的是synchronized是一个对象锁，也就是它锁的是一个对象。因此，无论使用哪一种方法，synchronized都需要有一个锁对象。
java如何防止死锁_Java 死锁以及如何避免？
weixin_30558777的博客
02-19 2485
Java中产生死锁的原因以及如何避免：1. Java中导致死锁的原因Java中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T1和T2永远被阻塞了。导致了死锁。这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程T1持有锁L...
java中的各种锁
杨宇昌的博客
05-14 621
java中的各种锁
java中都有哪些锁?
xx12321q的博客
06-03 3413
相信大家在学习java的过程中, 一定听到过很多, 关于java中的锁 , 但这些锁并不完全都是指一把真正的锁, java中的锁有的是指锁的实现, 而有的指的是锁的特性, 下面来介绍 目录 乐观锁与悲观锁 死锁 可重入锁 读写锁 分段锁 自旋锁 共享锁与独占锁 AQS 公平锁与非公平锁 偏向锁, 轻量级锁与重量级锁 java对象头 Synchronized ReetrantLock 乐观锁与悲观锁 乐观锁与悲观锁其实指的是看待并发问题的角度,并不是锁实现 ......
java中常用的锁
txwy12的博客
03-24 613
1、乐观锁 乐观锁是一种乐观思想，假定当前环境是读多写少，遇到并发写的概率比较低，读数据时认为别的线程不会正在进行修改（所以没有上锁）。写数据时，判断当前 与期望值是否相同，如果相同则进行更新（更新期间加锁，保证是原子性的）。 Java中的乐观锁： CAS，比较并替换，比较当前值（主内存中的值），与预期值（当前线程中的值，主内存中值的一份拷贝）是否一样，一样则更新，否则继续进行CAS操作。可以同时进行读操作，读的时候其他线程不能进行写操作。 2、悲观锁 悲观锁是一种悲观思想，即认为写多读少，遇到并发写的可能
java 线程死锁问题_Java多线程中的死锁问题
weixin_35816287的博客
02-13 186
Java程序基本都要涉及到多线程，而在多线程环境中不可避免的要遇到线程死锁的问题。Java不像数据库那么能够检测到死锁，然后进行处理，Java中的死锁问题，只能通过程序员自己写代码时避免引入死锁的可能性来解决。1. Java中导致死锁的原因Java中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T...
深入理解 Java 并发锁
m0_50414588的博客
04-02 4452
一、并发锁简介 确保线程安全最常见的做法是利用锁机制（Lock、sychronized）来对共享数据做互斥同步，这样在同一个时刻，只有一个线程可以执行某个方法或者某个代码块，那么操作必然是原子性的，线程安全的。 在工作、面试中，经常会听到各种五花八门的锁，听的人云里雾里。锁的概念术语很多，它们是针对不同的问题所提出的，通过简单的梳理，也不难理解。 可重入锁 可重入锁又名递归锁，是指同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。 可重入锁可以在一定程度上避免死锁。 Reentrant.
Java多线程死锁示例
08-27
主要介绍了Java多线程死锁,结合实例形式分析了Java多线程出现死锁的相关原因与操作注意事项,需要的朋友可以参考下
Java线程死锁实例及解决方法
08-25
主要介绍了Java线程死锁实例及解决方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java实现死锁的示例代码
08-28
本篇文章主要介绍了java实现死锁的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解Java中synchronized关键字的死锁和内存占用问题
09-02
Java的synchronized关键字用来进行线程同步操作,然而这在使用中经常会遇到一些问题,这里我们就来详解Java中synchronized关键字的死锁和内存占用问题:
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 991
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 786
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 287
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 256
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java中的锁
05-24
在 Java 中，锁是一种同步机制，用于控制多个线程对共享资源的访问。Java 提供了两种类型的锁：内置锁和显式锁。 1. 内置锁 内置锁是 Java 对象提供的一种锁机制，也称为监视器锁。每个 Java 对象都有一个内置锁，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值