线程安全以及如何避免死锁，线程通信

最新推荐文章于 2023-07-12 18:23:10 发布
最新推荐文章于 2023-07-12 18:23:10 发布
阅读量2.6k 收藏 1
点赞数
文章标签： 安全 java 开发语言
坤仔
本文链接：https://blog.csdn.net/weixin_56198901/article/details/122330981
版权

一，解决线程安全问题--加锁

1，synchronized 自动锁

synchronized () {}

()锁资源-----共享资源作为锁资源.只要使用的是同一把锁资源就可以上锁成功。必须是对象可以是（this或Object）

public class TestTicket {
    public static void main(String[] args) {
         Ticket task=new Ticket();//任务对象

         Thread t1=new Thread(task,"窗口A");
         Thread t2=new Thread(task,"窗口B");
         Thread t3=new Thread(task,"窗口C");
         Thread t4=new Thread(task,"窗口D");

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

class Ticket implements Runnable {

    private Integer ticket = 100;
    private Object o=new Object(); //新建一个Object做为锁资源
    @Override
    public void run() {
        while (true) {
            synchronized (this) { //()要的是一个对象！ tiket它是一个int类型
                if (ticket <= 0) {
                    break;
                }
                ticket--;
                System.out.println(Thread.currentThread().getName() + "卖了一张，剩余:" + ticket + "张");
            }
        }
    }
}

Lock 手动锁

Lock lock = new ReentrantLock();

 lock.lock(); 加锁

lock.unlock();解锁

/**
 * @program: thread02
 * @description:
 * @author: 坤仔
 * @create: 2022-01-05 15:57
 **/
public class Testhelloworld {
    private static String[] arr=new String[5];
    private static int index=0;

    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();
        Runnable hello = new Runnable(){
            @Override
            public void run() {
                try {
                    lock.lock();//重入锁 可以多次加锁，创建一个手动锁对象
                    if (arr[index]==null){
                        arr[index]="hello";
                        index++;
                    }
                } finally {
                    lock.unlock();//解锁
                }
            }
        };
        Runnable world = new Runnable(){
            @Override
            public void run() {
                try {
                    lock.lock();
                    if (arr[index]==null){
                        arr[index]="world";
                        index++;
                    }
                } finally {
                    lock.unlock();
                }
            }
        };
        Thread t1 = new Thread(hello, "AAA");
        Thread t2 = new Thread(world, "BBB");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(Arrays.toString(arr));
    }
}

二，死锁以及如何避免死锁

如何避免

1.尽量不要使用锁的嵌套。
2.尽量使用安全类。
3.可以lock锁的tryLock设置锁的时间。 

三，线程通信

唤醒 notify() 随机唤醒等待队列中的一个; notifyAll() 唤醒等待队列中的所有线程 

一存一取

/**
 * @program: thread02
 * @description:
 * @author: 坤仔
 * @create: 2022-01-05 16:22
 **/
public class TestBank {
    public static void main(String[] args) {
        Banck banck = new Banck(0);

        saveMoney saveMoney = new saveMoney(banck);
        takeMoney takeMoney = new takeMoney(banck);

        Thread t1= new Thread(saveMoney, "AAA");
        Thread t2 = new Thread(takeMoney, "BBB");
        t1.start();
        t2.start();
    }
}
class saveMoney implements Runnable{
    private Banck banck;

    public saveMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.savemoney(1000);
        }
    }
}
class takeMoney implements Runnable{
    private Banck banck;

    public takeMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.takemoney(1000);
        }
    }
}
class Banck{
    private double balnce;
    private boolean flag=false;

    public Banck(double balnce) {
        this.balnce = balnce;
    }
    public synchronized void savemoney(double money){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce+=1000;
        System.out.println(Thread.currentThread().getName()+"存入了1000元；卡中余额："+balnce);
        flag=true;
        this.notify();
    }
    public synchronized void takemoney(double money){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce-=1000;
        System.out.println(Thread.currentThread().getName()+"取出了1000元；卡中月"+balnce);
        flag=false;
        this.notify();
    }
}

多存多取

/**
 * @program: thread02
 * @description:
 * @author: 坤仔
 * @create: 2022-01-05 16:22
 **/
public class TestBank {
    //多存多取 出现余额变为负数的问题 解决方案 把if改为while 每次唤醒都做判断
    public static void main(String[] args) {
        Banck banck = new Banck(0);

        saveMoney saveMoney = new saveMoney(banck);
        takeMoney takeMoney = new takeMoney(banck);

        Thread t1= new Thread(saveMoney, "AAA");
        Thread t2 = new Thread(takeMoney, "BBB");
        Thread t3= new Thread(saveMoney, "CCC");
        Thread t4 = new Thread(takeMoney, "DDD");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class saveMoney implements Runnable{
    private Banck banck;

    public saveMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.savemoney(1000);
        }
    }
}

class takeMoney implements Runnable{
    private Banck banck;

    public takeMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.takemoney(1000);
        }
    }
}

class Banck{
    private double balnce;
    private boolean flag=false;

    public Banck(double balnce) {
        this.balnce = balnce;
    }
    public synchronized void savemoney(double money){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce+=1000;
        System.out.println(Thread.currentThread().getName()+"存入了1000元；卡中余额："+balnce);
        flag=true;
        this.notify();
    }
    public synchronized void takemoney(double money){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce-=1000;
        System.out.println(Thread.currentThread().getName()+"取出了1000元；卡中月"+balnce);
        flag=false;
        this.notify();
    }
}

结果

 结果

if改为while

public class TestBank {
    //多存多取 出现余额变为负数的问题 解决方案 把if改为while 每次唤醒都做判断
    public static void main(String[] args) {
        Banck banck = new Banck(0);

        saveMoney saveMoney = new saveMoney(banck);
        takeMoney takeMoney = new takeMoney(banck);

        Thread t1= new Thread(saveMoney, "AAA");
        Thread t2 = new Thread(takeMoney, "BBB");
        Thread t3= new Thread(saveMoney, "CCC");
        Thread t4 = new Thread(takeMoney, "DDD");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class saveMoney implements Runnable{
    private Banck banck;

    public saveMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.savemoney(1000);
        }
    }
}

class takeMoney implements Runnable{
    private Banck banck;

    public takeMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.takemoney(1000);
        }
    }
}

class Banck{
    private double balnce;
    private boolean flag=false;

    public Banck(double balnce) {
        this.balnce = balnce;
    }
    public synchronized void savemoney(double money){
        while (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce+=1000;
        System.out.println(Thread.currentThread().getName()+"存入了1000元；卡中余额："+balnce);
        flag=true;
        this.notify();
    }
    public synchronized void takemoney(double money){
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce-=1000;
        System.out.println(Thread.currentThread().getName()+"取出了1000元；卡中月"+balnce);
        flag=false;
        this.notify();
    }
}

结果：

 改善  使用notifyAll替换notify

/**
 * @program: thread02
 * @description:
 * @author: 坤仔
 * @create: 2022-01-05 16:22
 **/
public class TestBank {
    //多存多取 出现余额变为负数的问题 解决方案 把if改为while 每次唤醒都做判断
    public static void main(String[] args) {
        Banck banck = new Banck(0);

        saveMoney saveMoney = new saveMoney(banck);
        takeMoney takeMoney = new takeMoney(banck);

        Thread t1= new Thread(saveMoney, "AAA");
        Thread t2 = new Thread(takeMoney, "BBB");
        Thread t3= new Thread(saveMoney, "CCC");
        Thread t4 = new Thread(takeMoney, "DDD");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class saveMoney implements Runnable{
    private Banck banck;

    public saveMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.savemoney(1000);
        }
    }
}

class takeMoney implements Runnable{
    private Banck banck;

    public takeMoney(Banck banck) {
        this.banck = banck;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            banck.takemoney(1000);
        }
    }
}

class Banck{
    private double balnce;
    private boolean flag=false;

    public Banck(double balnce) {
        this.balnce = balnce;
    }
    public synchronized void savemoney(double money){
        while (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce+=1000;
        System.out.println(Thread.currentThread().getName()+"存入了1000元；卡中余额："+balnce);
        flag=true;
        this.notifyAll();
    }
    public synchronized void takemoney(double money){
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balnce-=1000;
        System.out.println(Thread.currentThread().getName()+"取出了1000元；卡中月"+balnce);
        flag=false;
        this.notifyAll();
    }
}

码农的坤仔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程基础安全问题、死锁及线程间通信详解
12-22
1、线程概述 1.1、基本概念 进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存 中的执行区域。 线程：就是在一个进程中负责一个执行路径。 多线程：就是在一个进程中多个执行路径同时执行。 电脑上的程序同时在运行，“多任务”操作系统能同时运行多个进程（程序），但实际是由于CUP分时机制的作用，使每个进程都能循环获得自己的CUP时间片，由于轮换速度非常快，使得所有程序好象是在“同时”运行一样。 与其说是快速的切换进程，还不如说是线程进行着CUP的资源争夺战。 1.2、多线程的利弊 1.2.1、 多线程好处 1、解决一个进程里可以同时执行多个任务； 2、提高了资源的利用率（不是效率）
源码解读及如何保证线程安全，掌门一对一java面试
最新发布
m0_61040489的博客
03-12 774
既已说到spring cloud alibaba，那对于整个微服务架构，如果想要进一步地向上提升自己，到底应该掌握哪些核心技能呢？就个人而言，对于整个微服务架构，像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识，架构师必经之路！下图，是自绘的微服务架构路线体系大纲，如果有还不知道自己该掌握些啥技术的朋友，可根据小编手绘的大纲进行一个参考。
如何避免事务造成的锁表？以及如何解决表锁
m0_45806184的博客
07-07 6452
​ 在数据库里，同一个数据可能有多个人来读取或更改，为了防止更改的时候别人也同时更改，这里一般要锁住表不让别人改，锁表发生在insert update 、delete 中
线程用synchronized产生死锁的问题及解决
wycyiyang的博客
04-16 1278
线程用synchronized产生死锁的问题及解决
解决线程不安全的3种方法
CherryBlossom_的博客
02-26 449
java八股文解决线程不安全的方法
【JavaEE】多线程之线程安全（synchronized篇），死锁问题
weixin_69417428的博客
01-16 1976
多线程的线程安全问题，以及死锁问题的详细讲解~~
synchronized:解决死锁的问题[轉貼]
热门推荐
冯立彬的博客
04-10 1万+
synchronized:解决死锁的问题[轉貼]最近对pv操作研究了一下，才发现原来java已经提供了内置的防死锁功能，不能不说它是很人性的了。下面就是整理的资料： 多线程的互斥与同步 　　临界资源问题 　　前面所提到的线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。但是经常有一些
[JavaEE]synchronized 与 死锁
Node_Hao的博客
01-09 2488
当某个线程执行到 synchronized 所修饰的对象时 , 该线程对象会加锁(lock) , 其他线程如果执行到同一个对象的 synchronized 就会产生阻塞等待.
JAVA多线程二（死锁，线程安全问题及解决：synchronized和Lock）
m0_61160520的博客
07-12 867
当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程`只有读操作`，那么不会发生线程安全问题。但是如果多个线程中对资源有`读和写`的操作，就容易出现线程安全问题。如何寻找问题并解决？
浅谈Python线程的同步互斥与死锁
12-20
线程间通信方法  1. 通信方法 线程间使用全局变量进行通信  2. 共享资源争夺 共享资源：多个进程或者线程都可以操作的资源称为共享资源。对共享资源的操作代码段称为临界区。 影响 ： 对共享资源的无序操作可能会...
一分钟用睡前小故事图解Java线程之死锁
12-22
线程执行的六大状态一、故事引入二、死锁死锁的产生三、线程通信等待通知四、代码案例线程释放锁标记主线程通知MyThread线程主线程通知哪个线程？ 为了更好的理解死锁，读者可能需要了解线程安全相关的知识，主要是...
java多线程安全性基础介绍.pptx
07-25
各线程之间变量不可见，线程通信通过共享主内存实现。 volatile 仅保证可见性 作用 不会被缓存在寄存器或其他对cpu不可见的地方 强制其他线程读主内存 编译器和运行时不会讲该变量的操作与其他内存操作一起重...
Java编程之多线程死锁与线程间通信简单实现代码
08-29
主要介绍了Java编程之多线程死锁与线程间通信简单实现代码，具有一定参考价值，需要的朋友可以了解下。
【多线程】| 线程冲突解决方案
狮子也疯狂的博客
05-22 1704
同一进程内的线程是共享同一内存空间的，所以在多个线程的进程里，线程是可以同时操作这个进程空间的数据的，这样就容易造成线程冲突的情况。举个小李子：一个房子里（代表一个进程），只有一个厕所（代表一个资源）。屋子里面有两个人A和B（代表两个线程），共用这个厕所。一天A去上厕所了，一上就仨小时。到第三个小时的时候，B实在忍不住了，直接就开门进去把在里面玩手机的A轰了出来。然后A就被赶出来了，嘴里骂骂咧咧……这里说明了什么呢？？？
线程安全
qq_43446343的博客
03-29 197
线程安全 1. Java内存模型 Java虚拟机规范中试图定义一种Java内存模型（JMM）来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。 java内存模型的主要目标是定义程序中各个变量的访问规则，就是在虚拟机中将变量存储到内存和从内存中取出变量的底层细节。 每个线程都有自己的工作内存，而JMM规定了所有的变量都存储在主内存中，线程只能使用...
使用synchronized产生的死锁问题及其解决
zcyt085的博客
09-06 6582
synchronized 死锁 synchronized作为解决并发编程中原子性、可见性和有序性问题的万能钥匙。其带来的是性能上的问题。使用synchronized关键是看充当锁的角色，锁的作用是保护资源，我们要确定其锁定的范围囊括了需要保护的资源。我们知道synchronized(类名.class){}的用法，类名.class是一个Class的对象，只在JVM中存在一份，所以在不考虑分布式的情况下，这个用法真的可以说是“万能”的。但是通用的背后带来的是性能的问题，如现在有一个账户类（Account），如果
如何保证线程安全？和防止死锁？（面试必问）
weixin_50838394的博客
08-02 277
如何保证线程安全？和防止死锁？（面试必问）
多线程 - 什么是线程死锁？怎么避免？
学无止境
03-23 1309
线程死锁是指两个或多个线程相互等待对方释放锁资源，导致所有线程都无法继续执行的一种情况。如果不处理，死锁会导致应用程序的异常终止，降低系统的可用性。线程死锁的避免可以从以下几个方面入手：1、避免一个线程同时获取多个锁。如果不可避免，可以统一获取锁的顺序，避免交叉获取锁导致死锁。2、避免一个线程在等待另一个线程持有的锁的同时，还持有自己的锁。可以在持有锁的时候，尽快处理完需要持有锁的逻辑，释放锁资源。3、尽量减少锁的持有时间。可以使用并发容器等无锁数据结构，减少锁的竞争。
qt 线程通信的方式
08-31
Qt线程通信有多种方式，以下是常用的几种： 1. 信号与槽机制（Signal and Slot）：是Qt中最常用的线程通信方式。通过在一个对象中定义一个...在进行线程通信时，需要注意避免死锁和竞态条件等多线程编程中常见的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值