Java基础_22线程死锁，object类下面线程方法，生产者消费者

最新推荐文章于 2024-11-15 18:38:47 发布
最新推荐文章于 2024-11-15 18:38:47 发布
阅读量1k 收藏 8
点赞数 26
分类专栏： java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44682264/article/details/137832171
版权 
周二的回顾
1.线程的概念
	是进程(应用程序软件)最小的基本单位
2.在Java中代码咋写线程
	1.继承Thread类
	2.实现Runnable接口
	3.实现Callable接口
3.Thread相关的方法
	
4.同步锁
	目的:   当多个线程操作同一个资源的时候，会发生数据不安全性！！！
	加锁目的:   保证只有一个线程在操作咱们的资源  卖票的！！！
	1.同步方法  synchronized
	2.同步代码块  
	3.lock

今天的内容

1.守护线程

2.线程的生命周期

3.死锁

4.关于Object类下面和线程有关的方法【重点】

5.生产者消费者【难点重点】

1.守护线程【非重点】

守护线程是用来守护其他线程的（其他线程不是守护）

每个线程可能也可能不会被标记为守护程序。（靠咱们的代码来处理）

开启线程，一般不是守护线程，除非咱们使用代码将他变成守护线程

被守护的线程一旦结束，守护线程就会挂掉。

守护线程依附于非守护线程。如果非守护线程消亡。那么守护没有执行完也要挂掉！！！

帝王制度。皇帝（被守护线程）死了，妻子（守护线程）要陪葬

package com.qf.a_demon;


class MyThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread1(), "狗蛋");
      //setDaemon(boolean on)
        //将此线程标记为daemon线程或用户线程。 当运行的唯一线程都是守护进程线程时，Java虚拟机将退出。
        //线程启动前必须调用此方法。
        thread.setDaemon(true);//设置为守护线程
        thread.start();
        System.out.println(Thread.currentThread().isDaemon());
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程:" + i);
        }

    }
}

2.线程的生命周期

  • 新建状态:

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

  • 就绪状态:

    当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

  • 运行状态:

    如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:

    如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

    • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
    • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
    • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

  • 死亡状态:

    一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.死锁

开发中禁止使用死锁

面试会问：

​ 应用场景：并发场景，多线程。线程之间互不相让。

线程加锁的目的就是为了安全。但是物极必反。

死锁是一种状态，当两个线程互相持有对方的资源的时候，却又不主动释放对方的资源。会导致死锁。代码不会正常的执行。这两个线程就会僵持住。哪个线程都不能往下执行。

线程1 有锁1 线程1想要使用锁2

线程 2 有锁2 线程2想要使用锁1

开锁公司需要身份证。开锁公司给你说: 先出示身份证再开锁 你说: 先开锁，因为身份证在屋里面 所以僵持不下

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

(6条消息) 什么是线程死锁?如何避免死锁?_TanaStudy的博客-CSDN博客

线程1拿到了锁1对象
线程2拿到了锁2对象
等待锁2的释放...
等待锁1的释放...

package com.qf.c_sisuo;


class DeadLock implements Runnable {
    private boolean flag;//标记属性
    private Object obj1;//资源1
    private Object obj2;//资源2
    //有参构造方法


    public DeadLock(boolean flag, Object obj1, Object obj2) {
        this.flag = flag;
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    @Override
    public void run() {
        if (flag) {//flag为true的时候  让线程1进来执行if语句中代码
            synchronized (obj1) {//锁obj 1资源
                System.out.println(Thread.currentThread().getName() + "拿到了obj1对象");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //线程1走到这个方法不走了，休眠了
                System.out.println("我的线程1想拿obj2这个资源");
                synchronized (obj2) {//如果obj2一直没有释放，是锁不住这个资源的！！！
                    System.out.println(Thread.currentThread().getName() + "拿到了obj2对象");

                }

            }
        }
        
        //线程1拿到了obj1对象
        //线程2拿到了obj2对象
        //我的线程1想拿obj2这个资源
        //线程1拿到了obj2对象
        //
        //Process finished with exit code 0
        if (!flag) {//flag为false的时候  让线程2进来执行if语句中代码
            synchronized (obj2) {//锁obj 1资源
                System.out.println(Thread.currentThread().getName() + "拿到了obj2对象");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我的线程2想拿obj1这个资源");
                synchronized (obj1) {//如果obj2一直没有释放，是锁不住这个资源的！！！
                    System.out.println(Thread.currentThread().getName() + "拿到了obj1对象");

                }
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();
        //第一个线程
        DeadLock deadLock1 = new DeadLock(true, obj1, obj2);
        new Thread(deadLock1, "线程1").start();
        //第二个线程
        DeadLock deadLock2 = new DeadLock(false, obj1, obj2);
        new Thread(deadLock2, "线程2").start();
    }
}

4.和线程相关的Object类方法

Object类的方法

public final void wait(long timeout)
             throws InterruptedException

导致当前线程等待，直到另一个线程调用此对象的notify()方法或notifyAll()方法，才能够唤醒当前等待线程！！！

总结：两个线程，其中一个线程 对象.wait()方法，那么这个线程就会阻塞。什么叫阻塞？这个线程暂时

不执行了。如何让这个线程继续往下执行呢？再开另外一个线程。对象.notify()去唤醒另外一个线程！！！


等待线程:0
等待线程:1
等待线程:2
等待线程:3
等待线程:4
等待线程:5
等待线程:6
等待线程:7
等待线程:8
等待线程:9  以上是等待线程

唤醒线程:0
唤醒线程:1
唤醒线程:2
唤醒线程:3
唤醒线程:4
唤醒线程:5
唤醒线程:6
唤醒线程:7
唤醒线程:8
唤醒线程:9
唤醒线程已经将等待线程唤醒  以上是唤醒线程   唤醒线程目的是唤醒等待线程


野猪:0
野猪:1
野猪:2
野猪:3
野猪:4
野猪:5
野猪:6
野猪:7
野猪:8
野猪:9  以上是等待线程

Process finished with exit code 0

把消费者看成等待线程！！！ 把生产者看成唤醒线程！！！

消费一个黄焖鸡！！！

​


还未出餐:0
还未出餐:1
还未出餐:2
还未出餐:3
还未出餐:4
还未出餐:5
还未出餐:6
还未出餐:7
还未出餐:8
还未出餐:9     消费者   点外卖的哥们   等待线程



唤醒线程:0
唤醒线程:1
唤醒线程:2
唤醒线程:3
唤醒线程:4
唤醒线程:5
唤醒线程:6
唤醒线程:7
唤醒线程:8
唤醒线程:9
唤醒线程已经将等待线程唤醒     生产者   唤醒线程


已经出餐0
已经出餐1
已经出餐2
已经出餐3
已经出餐4
已经出餐5
已经出餐6
已经出餐7
已经出餐8
已经出餐9      消费者得到     等待线程中

Process finished with exit code 0

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

总结：

新建两个线程：
	一个是等待线程
		等待线程中代码从上往下执行，但是使用object.wait()方法以后，咱们当前的线程就等待了，阻塞了
		到wait之后代码暂时不会往下执行了，需要借助于另外一个线程进行唤醒。
	一个是唤醒线程
		唤醒线程使用object.notify方法去将 等待线程中的正在等待的线程进行唤醒，让等待线程继续往下执行
		
好比：  在大学谈了个女朋友。你给你女朋友打电话晚上去吃饭，你女朋友说你来接我吧，到楼底下等着我
你在楼底下等着，你就是等待线程。你女朋友就是唤醒线程。你女朋友要化妆。化两个小时。你就得站在楼底下等两个小时，等你女朋友化完妆以后，她来唤醒你，说 走吧。然后你和她一起开开心心的去吃
	咱们wait和notify方法 实现线程之间的通信问题。
	
	
	我点了一份宫保鸡丁  我得等待  就是等待线程
	商家做好以后，唤醒我  别等了哥们。做好了吃吧  商家就是唤醒线程

package com.qf.c_object;

//为啥要写Message这个类？
//wait需要对象.wait()   先有类然后再创建对象  message.wait()
class Message {
    private String message;//信息

    public Message(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

}
//等待线程
class WaiterThread implements Runnable {
    private Message msg;//要使用msg对象    msg.wait()

    public WaiterThread(Message msg) {
        this.msg = msg;
    }
    //为啥写构造方法，WaiterThread和NotifierThread里面 保证是同一个message对象

    @Override
    public void run() {
        //等待线程中获取线程的名字
        String name = Thread.currentThread().getName();
        System.out.println( name + "等待唤醒的时间:" + System.currentTimeMillis());
       //wait等待唤醒的时间:1670381924163
        synchronized (msg) {
            try {
                msg.wait();//当前线程会等待 不会往下执行。
                //为啥要加synchronized，当调用wait方法的时候
                //会自动释放锁，然后msg对象放到对象的等待池中
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "被唤醒的时间:" + System.currentTimeMillis());
            System.out.println(name + "线程"+ msg.getMessage());
        }
    }
}
//唤醒线程
class NotifierThread implements Runnable {
    private Message msg;//使用msg对象  msg.nitify() 去唤醒等待线程

    public NotifierThread(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(10000);//唤醒线程睡10秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String name =Thread.currentThread().getName();
        System.out.println(name + "开始唤醒等待线程");
        synchronized (msg) {
            msg.setMessage("我是修改之后的message对象");
            //msg.notify();//去唤醒等待线程让等待线程继续往下执行
            msg.notifyAll();//去唤醒所有的等待线程
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Message message = new Message("我是message对象");
        WaiterThread waiterThread = new WaiterThread(message);

        //如果有两个等到线程呢？
        NotifierThread notifierThread = new NotifierThread(message);
        new Thread(waiterThread, "wait").start();
        new Thread(waiterThread, "wait1").start();
        new Thread(notifierThread, "notify").start();
    }
}


package com.qf.d_waitnotify;


class Message {
    private String message;

    public Message(String message) {

        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
class WaitThread implements Runnable{
    private Message message;

    public WaitThread(Message message) {
        this.message = message;
    }

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+ ":" + i);
        }

        //0x998.wait()
        synchronized (message) {
            try {
                message.wait();//线程等待
                //为啥要用！！！当调用wait方法的时候，会自动的释放这个锁
                //把资源 message 放到对象的等待池中。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+ i);
        }
    }
}
class NotifyThread implements Runnable{
    private Message message;

    public NotifyThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+ ":" + i);
        }
       //0x998.notify();
        synchronized (message) {
            message.setMessage("已经出餐");
            //message.notify();
            message.notifyAll();
        }
        System.out.println("唤醒线程已经将等待线程唤醒");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Message message = new Message("还未出餐");//0x998
        WaitThread waitThread = new WaitThread(message);
        NotifyThread notifyThread = new NotifyThread(message);
        new Thread(waitThread, "等待线程1").start();
        new Thread(waitThread, "等待线程2").start();
        new Thread(notifyThread, "唤醒线程").start();
    }
}

总结：

Object类
wait()
notify()
notifyAll()

5.join方法【开发不用】

为啥join方法放在wait方法之后，因为join方法的底层是wait()方法

作用：让主线程等待，一直等待他的子线程执行完以后，才执行主线程

控制线程执行的顺序的！！！

package com.qf.d_join;

class Mythread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.err.println(Thread.currentThread().getName() + ":" + i);
        }

    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Mythread1());
        thread.start();
        thread.join();//主线程开始等待子线程执行完以后再执行主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }

    }
}


package com.qf.d_join;

class FatherThread implements Runnable {
    @Override
    public void run() {

        //在FatherThread线程中去启动SonThread这个线程
        Thread thread = new Thread(new SonThread());
        //SonThread  是在FatherThread线程启动的，那就意味着
        //SonThread是FatherThread的一个子线程
        thread.start();
        try {
            thread.join();//thread的父线程
            //让主线程（父线程）等待，等到子线程执行完以后再执行父线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
            System.out.println("父亲线程:" + i);
        }


    }
}
class SonThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.err.println("儿子线程:"+ i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        new Thread(new FatherThread()).start();
    }
}

面试题：

你如何控制两个线程的执行顺序。
1.sleep  让另外一个线程先执行。睡完以后再执行其他线程
2.join   使用join让子线程先执行完
3.线程池

6.生产者消费者模式

生活中案例：

​ 卖家：汽车厂商 生产者

​ 买家: 咱们班40位同学 消费者

​ 狗蛋想买一个BYD汉 ，电车定完车以后需要等。

​ 狗蛋告知汽车厂商我要买车。如果有，直接发货。如果没有呢？ 狗蛋会进入到等待状态。等汽车厂商生产好以后，唤醒狗蛋的等待线程。然后狗蛋来买车。如果今天没有人买车。汽车厂商进入到等待状态。

如果有人买车，立马唤醒汽车厂商线程，让他赶紧造车

生产者: 汽车厂商

消费者: 梦圆

美团 饿了吗 等都是这种模式

梦圆（消费者）想吃饭？咋办？

去饭店，然后说老板(生产者)我要吃酸菜鱼。老板说好 你等着。梦圆就进入到等待wait状态！！

饭做好了，老板，唉 哥们 做好了吃饭（唤醒梦圆（消费者））。梦圆在吃饭的时候

饭店在干嘛没有人再来吃饭。饭店阻塞状态 等待，等再上人。

现在看第一个问题：
	为啥是消费者抢到这个执行权，等了10秒以后才执行消费这线程！！！我让消费者睡了10s
	因为goods  是false 肯定生产者线程先抢到这个执行权，为啥？因为消费者睡觉。
	但是没有执行生产者，为啥？因为生产者在wait 有车。一旦wait 等过了10s以后
	消费者线程睡醒了，之后先执行消费者
	
	true之后又唤醒了生产者，让生产者 去生产者
	

消费者购买了:五菱，价格为:76.0
生产者生产了:兰博基尼价格为:200.0
消费者购买了:兰博基尼，价格为:200.0
生产者生产了:玛莎拉蒂价格为:300.0
消费者购买了:玛莎拉蒂，价格为:300.0
生产者生产了:兰博基尼价格为:200.0
消费者购买了:兰博基尼，价格为:200.0
生产者生产了:玛莎拉蒂价格为:300.0
消费者购买了:玛莎拉蒂，价格为:300.0
生产者生产了:兰博基尼价格为:200.0
消费者购买了:兰博基尼，价格为:200.0
生产者生产了:玛莎拉蒂价格为:300.0


package com.qf.e_shenchanzhexiaofezhe;

//为啥要写这个类？是作为两个线程之间的桥梁的共享资源
class Goods {
    private String name;//商品的价格
    private double price;//商品的价格
    private boolean isProduct;//是否需要生产？
    //true需要生产  false  不需要生产

    public Goods(String name, double price, boolean isProduct) {
        this.name = name;
        this.price = price;
        this.isProduct = isProduct;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public boolean isProduct() {
        return isProduct;
    }

    public void setProduct(boolean product) {
        isProduct = product;
    }
}
//消费者线程
class Customer implements Runnable {
    private Goods goods;

    public Customer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        //消费者消费
        try {
            Thread.sleep(10000);//这个可写可不写
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //生产者一直生产，消费者一直消费
        while(true) {
            synchronized (goods) {
                //一直消费。判断商品是否有无？
                true需要生产(没有商品)  :false  不需要生产（有商品）
                if (!goods.isProduct()) {
                    //有商品的情况: 直接购买，购买完以后没有商品了
                    System.out.println("消费者购买了:" + goods.getName()+ "，价格为:" + goods.getPrice());
                    //购买完以后商品没了，去修改标记flag  然后唤醒生产者
                    goods.setProduct(true);
                    //唤醒生产者生产
                    goods.notify();
                } else {
                    //没有商品的情况: 生产者需要生产，消费者在等待,生产者线程要执行的
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

}
//生产者线程
class Productor implements Runnable {
    private Goods goods;

    public Productor(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        int count = 0;
        //生产者生产
        while (true) {//死循环
            synchronized (goods) {
               if (goods.isProduct()) {//true 需要生产
                  //造车,如果是奇数的话，造玛莎拉蒂 如果偶数造另外一种车 兰博基尼
                   if (count % 2 == 0) {//偶数
                       goods.setName("兰博基尼");
                       goods.setPrice(200);
                   } else {//奇数
                       goods.setName("玛莎拉蒂");
                       goods.setPrice(300);
                   }
                   //生产者一定要把flag属性设置false
                   goods.setProduct(false);//false 有车了就不需要生产了
                   System.out.println("生产者生产了:" +goods.getName() + "价格为:" + goods.getPrice());
                   count++;
                   //生产完以后，消费者消费。在生产的时候，消费者在干嘛？消费者在等待
                   //唤醒消费者
                   goods.notify();

               } else {//不需要生产车  生产者在等待
                   try {
                       goods.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //fasle不需要生产
        Goods goods = new Goods("五菱", 76, false);
        //两个线程共享是一个资源
        Customer customer = new Customer(goods);
        Productor productor = new Productor(goods);
        new Thread(customer).start();
        new Thread(productor).start();

    }
}


步骤:
	1.goods类   共享资源  实体类
	2.建一个消费者 类   一定是线程类
			如果有商品就消费。
			如果没有商品就等待
	3.建一个生产者类   线程类
			如果有商品就等待
			如果没有商品就生产
	4.main
		开启这两个线程

otify();

           } else {//不需要生产车  生产者在等待
               try {
                   goods.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        }
    }
}

}
public class Demo1 {
public static void main(String[] args) {
//fasle不需要生产
Goods goods = new Goods(“五菱”, 76, false);
//两个线程共享是一个资源
Customer customer = new Customer(goods);
Productor productor = new Productor(goods);
new Thread(customer).start();
new Thread(productor).start();

}

}

步骤:
1.goods类 共享资源 实体类
2.建一个消费者 类 一定是线程类
如果有商品就消费。
如果没有商品就等待
3.建一个生产者类 线程类
如果有商品就等待
如果没有商品就生产
4.main
开启这两个线程
码叔义
关注
专栏目录
java小白零基础（十一）死锁，Object类下面的和线程相关的方法，线程，生产者消费者模式，线程池，反射，设计模式
A17719032175的博客
04-14 142
死锁，Object类下面的和线程相关的方法，线程，生产者消费者模式，线程池，反射，设计模式
java—多线程的通信、生产者与消费者模式
12-21
本文将深入探讨Java中的线程通信、生产者-消费者模式，并解释相关的关键概念。 一、线程通信 线程通信是多线程环境下解决线程间数据交互的方式。在Java中，主要通过`wait()`, `notify()`, `notifyAll()`三个方法...
Java多线程下生产者消费者问题的五种同步方法实现
ai-exception的博客
05-21 1876
本文目录： 文章目录概述`wait() / notify()`方法实现`await() / signal()`方法`BlockingQueue`阻塞队列方法`Semaphore`方法实现同步`PipedInputStream` / `PipedOutputStream` 概述 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。 　　 生产者消费者模式的优点: 解耦 支持并发 支持忙...
java多线程一 基本实现方法、消费者生产者队列、死锁
hxshine的博客
01-10 3213
1.基本概念图 四个状态、start 代表被创建、run表示正在运行、阻塞（在干别的事情去了，可以把资源空出来给别人用）、死亡。 核心思想是提高cpu的使用率，你干别的事去了我来利用cpu啊，难点是同步，同时访问数据，一个厕所只有一个坑，俩个人一起上是不文明的。 参考：http://blog.csdn.net/zjwcdd/article/details/51517096 2.基本
详解多线程死锁&lock锁&生产者消费者问题
weixin_51787261的博客
01-07 1974
死锁 定义 多个线程各自占有一些公共资源，并且互相等待其它线程占有的的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况，某一个同步块同时拥有“两个以上对象的锁”，就可能发生死锁问题。 ...
java:多线程解决生产者消费者问题
qq_55630615的博客
04-15 844
一个简单的多线程问题,当处理逻辑不完善时,容易出现所有线程都在等待的死锁情况.我在一开始写的时候,使用的是notify()方法,这会导致每次只唤醒一条线程,但如果之前出现了消费者或生产者的连续抢到cpu控制权情况,之前沉睡的线程就并不止有一条,最终导致全部等待的死锁情况.贴两张运行结果直观一点。
Java多线程编程（四）——死锁问题
金鳞踏雨
01-08 1202
死锁 什么是死锁？ 线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行 什么情况下会产生死锁？ （1）资源有限 （2）同步嵌套 这里我们使用的是Lambda的写法 Coding： package 多线程.ThreadDemo09_死锁; public class Demo { public static void main(String[] args) { Object objA = new Object().
Java--多线程之生产者消费者模式；线程池ExecutorService（五）
MinggeQingchun的博客
10-12 2073
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。
Java多种方式解决生产者消费者问题（十分详细）
热门推荐
爱你の大表哥的博客
08-16 6万+
生产者消费者问题 一、问题描述 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，然后重复此过程；与此同时，消费者也在缓冲区消耗这些数据。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗...
Java线程同步与死锁、生产者消费者模式以及任务调度等
吃果冻不吐果冻皮
05-28 1659
Thread类基本信息方法 线程同步 由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchr
线程_死锁_生产者消费者模式(信号灯法)_任务调度JAVA180-182
好好学习天天向上
01-24 867
一、S02E180_01线程_死锁二、S02E181_01线程_生产者消费者模式(信号灯法)三、S02E182_01线程_任务调度
Java多线程中不同条件下编写生产消费者模型方法介绍
08-28
Java中的生产者消费者模型是一种经典的多线程设计模式，它用于解决两个或多个并发执行的线程之间的数据交互问题。在这个模型中，生产者线程负责生成数据，而消费者线程则负责处理这些数据。两者之间通过一个共享的...
Java编程之多线程死锁与线程间通信简单实现代码
08-29
下面我们就来详细介绍Java编程之多线程死锁与线程间通信简单实现代码。 一、死锁的定义和实现 死锁是指两个或者多个线程被永久阻塞的一种局面，产生的前提是要有两个或两个以上的线程，并且来操作两个或者多个以上...
Mybatis
最新发布
庸不易的博客
11-15 406
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 436
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
刷题---顺序表算法题
weixin_63997543的博客
11-11 448
顺序算法题----力扣刷题
SpringBoot 实现图片加水印
心猿意码
11-11 417
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 420
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
java加锁问题详解
qq_74056922的博客
11-14 514
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值