同步(进阶)/死锁问题/生产者消费者问题java多线程(二)

已于 2022-04-14 14:00:26 修改
阅读量585 收藏
点赞数
分类专栏： javaee 文章标签： java
于 2022-03-21 13:09:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45056135/article/details/123632455
版权

第一部分:线程不安全的三大案例:

1.集合列表案例:
// 线程不安全 同一瞬间将两个数组添加到了同一个位置
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        System.out.println(list.size()); // 小于10000
    }
}
2.购票案例(会出现负的票数):
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "苦逼的我").start();
        new Thread(buyTicket, "牛逼的你们").start();
        new Thread(buyTicket, "黄牛党").start();

    }
}
class BuyTicket implements Runnable{

    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        if(ticketNums <= 0){
            flag = false;
            return ;
        }
        Thread.sleep(50);
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}
解决方法:(buy方法中加一个synchronized 同步方法)
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "苦逼的我").start();
        new Thread(buyTicket, "牛逼的你们").start();
        new Thread(buyTicket, "黄牛党").start();

    }
}
class BuyTicket implements Runnable{

    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        if(ticketNums <= 0){
            flag = false;
            return ;
        }
        Thread.sleep(50);
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}
3.银行取钱案例:
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");

        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.start();
    }
}

class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing extends Thread{
    Account account;
    int drawingMoney;
    int nowMoney;
    
    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        super.run();
         if (account.money-drawingMoney < 0){
              System.out.println(Thread.currentThread().getName()+"钱不够了， 取不了");
              return;
          }
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          account.money = account.money-drawingMoney;
          nowMoney = nowMoney + drawingMoney;
          System.out.println(account.name +"余额为"+account.money);
          System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}
解决方法:(加一个同步块)
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");

        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.start();
    }
}

class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing extends Thread{
    Account account;
    int drawingMoney;
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        super.run();
        synchronized (account){
            if (account.money-drawingMoney < 0){
                System.out.println(Thread.currentThread().getName()+"钱不够了， 取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money-drawingMoney;
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name +"余额为"+account.money);
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
    }
}

第二部分: 线程死锁问题：

//死锁 多个线程互相拥抱着对象的资源 然后僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");
        g1.start();
        g2.start();
    }
}
class Lipstick{

}

class Mirror{

}

class Makeup extends Thread{
    static Lipstick lipstick = new Lipstick();  // 保证只有一个
    static Mirror mirror = new Mirror();


    int choice;//选择
    String girlName;

    public Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        super.run();
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    // 化妆
    private void makeup() throws InterruptedException {
        if(choice==0){
            synchronized (lipstick){
                System.out.println(lipstick);
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }

        }else{
            synchronized (mirror){
                System.out.println(lipstick);
                System.out.println(this.girlName+"获得口红的锁");
                synchronized (lipstick){
                    System.out.println(this.girlName+"获得的镜子锁");
                    Thread.sleep(1000);

                }
            }
        }
    }
}

解决方法(不要锁中套锁)

lock锁的应用

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{
    private final ReentrantLock lock = new ReentrantLock();
    int ticketNums = 10;
    @Override
    public void run() {
        while(true){
            try {
                lock.lock(); // 锁住
                if(ticketNums > 0){
                    try {
                        Thread.sleep(1000);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":\t"+ticketNums--);
                }else{
                    break;
                }
            }finally {
                lock.unlock(); //释放锁
            }

        }

    }
}

第三部分:线程同步方法

1.生产者消费者模式
// 生成者消费者 管程法
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        Productor productor = new Productor(container);
        Consumer consumer = new Consumer(container);

        productor.start();
        consumer.start();

    }
}

class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");

        }
    }
}

class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            container.pop();
            System.out.println("消费了第"+i+"只鸡");
        }
    }
}

class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    Chicken[] chickens = new Chicken[10];

    int count;

    public synchronized void push(Chicken chicken){
        if (count==chickens.length){
            //容器满了 通知消费者消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count] = chicken;
        count++;

        //生产完了可以消费了
        this.notifyAll();
    }

    public synchronized Chicken pop(){
        if (count == 0){
            //容器空 通知生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];

        //吃完了 通知生产者生产
        this.notifyAll(); // 释放锁
        return chicken;
    }
}
2.信号灯法
public class TestPC2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者演员
class Player extends Thread{
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("快乐大本营播放");
            }else{
                this.tv.play("记录美好生活");
            }
        }
    }
}

//消费者 观众
class Watcher extends Thread{
    Tv tv;

    public Watcher(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

class Tv{
    String voice;
    boolean flag = true;

    public synchronized void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("表演了:"+voice);
        this.voice = voice;
        this.flag = !this.flag;
        this.notifyAll();
    }

    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了"+voice);
        this.flag = !this.flag;
        this.notifyAll();
    }
}
CodeWang_NC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA死锁and生产者消费者问题
06-02
死锁and生产者消费者问题
Java实现生产者消费者问题
12-22
　生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况： 　生产者消费者...
Java线程同步与通信案例——生产者消费者问题
qq_39382032的博客
08-15 207
目录概述生产者与消费者模型实现代码 概述 生产者消费者问题是一个计算机领域的经典案例，计算机专业的同学在学习操作系统这门课时，一定会对此有所了解。下面就使用Java提供的多线程来实现这个案例。主要涉及到了线程间同步与线程间通信。 目前所学的创建多线程的常用方法包括：继承Thread类、实现Runnable接口（后续还有其他实现多线程的方法） 实现线程同步的常用方法包括：同步代码块、同步方法、锁Lock 实现线程间通信的常用方法包括：waiting()、notify()、notifyAll() 生产者与消费者
2016-08-19-java-关于线程的死锁的案例分析：生产者消费者问题
妈的小可爱
08-19 864
版本一（本人自己版）： package com.shi.onclass; import java.util.ArrayList; import java.util.List; import java.util.Random; /** * 关于生产者消费者线程的问题 * 两个对象：做面包的||吃面包的 * 两个方法：吃面包的方法||做面包的方法 * @author Shi * 1.定
线程的相关知识、JAVA实现死锁、生产者消费者问题
JAVA程序猿
01-20 519
线程有五种状态：创建、就绪、运行、阻塞、结束 isAlive:判断线程是否活着。就绪、运行、阻塞是活着，创建、结束是死了 getPriority、setPriority:设置优先级，明显的是，优先级高的，cpu分的时间片多一点 sleep：Thread.sleep(毫秒) 让当前线程休眠多少毫秒 join:合并两个线程，当执行到这个方法的时候，等当前线程执行完，再执行主线程。 yield
死锁，生产者消费者问题，线程池
Hanshhh的博客
01-26 266
死锁 死锁：多个线程互相抱着对方需要的资源，形成僵持！ package com.tao.Thread.Thread2; public class DeadLock { public static void main(String[] args) { makeup g1 = new makeup(0, "灰姑凉"); makeup g2 = new makeup(1, "白雪公主"); g1.start(); g2.start();
Java Swing多线程死锁问题解析
08-10
绍Java Swing多线程死锁问题解析
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
Java多线程--避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
Java多线程 线程同步与死锁
08-30
主要介绍了 Java多线程 线程同步与死锁的相关资料,需要的朋友可以参考下
java多线程（同步和死锁，生产者和消费者问题）
weixin_33971205的博客
06-23 66
首先我们来看看同步与死锁： 所谓死锁。这是A有banana，B有apple。 A至B说：你把apple对我来说，，我会banana给你。 B至A说：你把banana对我来说，，我会apple给你。 可是A和B都在等待对方的答复。那么这样终于的结果就是A得不到apple，B也得不到banana。这样的死循环就是死锁。 于是我们能够模拟上面的描写叙述，写出下面代码： ...
Java线程同步与通信(生产者消费者问题)
weixin_44092159的博客
08-03 157
1.同步代码块 synchronized（Object o）{ //同步代码 } public class WindowTest2 { public static void main(String[] args) { new Window2("窗口1").start(); new Window2("窗口2").start(); new Window2("窗口3").start(); } } class Window2 extends Th
java 生产者消费者问题-多线程与死锁
Eric's Blog
04-20 730
java 生产者消费者问题-多线程与死锁
【JavaSE学习笔记】多进程同步经典题目：生产者与消费者
qq_43530796的博客
04-09 451
自己手写了一遍生产者与消费者经典题目：
javase之通过生产者消费者模式解决死锁
Richard_666的博客
02-24 240
package com.ljl.thread; /** * 一个场景,共同的资源 * 生成者消费者模式--信号灯法 * @author Richard * wait() :等待，释放锁 * sleep() :等待，不释放锁 * notify()/notifyAll() :唤醒 与synchronized一起使用 * */ public class Movie { pri...
【Java】生产者消费者模式避免线程死锁
不会写代码的狗子
08-29 961
当多个线程使用同一资源时候会造成死锁，此时，可以使用生产者消费者模式来避免线程死锁 标志位来做信号灯控制线程防止deadlock flag-true:生产者生产，消费者等待，生产完成后，通知消费 flag-false:消费者消费，生产者等待，消费完成后，通知生产 在模拟中，share类模拟共享资源，如果flag位true，则this.wait(),声场完成后，notify()后，置flag为...
2021-09-02Java多线程生产者消费者问题（synchronized）
qq_29390683的博客
09-02 203
Java多线程案例(一) 文章目录Java多线程案例(一)同步和互斥的基本概念互斥同步生产者-消费者问题互斥操作示例代码 开发中线程的运行状态不固定，所以利用线程的名字和当前执行现成的对象进行区分 多个线程间也可能出现数据交互问题 以下介绍部分多线程问题的java实现 首先介绍以下同步和互斥的概念 同步和互斥的基本概念 互斥 互斥是指散步在不同任务之间的若干程序片断，当某个任务运行其中一个程序片段时，其它任务就不能运行它们之中的任一程序片段，只能等到该任务运行完这个程序片段后才可以运行，最基本的场景就是对资
java 同步list_java线程生产者与消费者实例（使用List实现同步）
weixin_30036893的博客
02-12 299
学习java线程的时候，看到生产者与消费者例子，有感而发。下面是模拟汽车生产商和顾客(权当消费者可以直接从厂家买到汽车)，废话不说，上代码。package com.zx.thread.work;import java.io.FileNotFoundException;import java.util.ArrayList;import java.util.List;import java.util....
死锁、生产者和消费者问题
m0_62574889的博客
05-16 324
生产者和消费者问题 死锁的概念 内存的基础知识 内存管理的概念 覆盖与交换 介绍一下PCB 连续分配管理方式​编辑
进程与线程，同步与死锁，生产者消费者模式
rabbit_in_android的博客
12-05 1779
1      进程与线程，同步与死锁，生产者消费者模式，等待wait与唤醒notify 《开实》： 线程的5中状态：创建new，就绪start()，运行run()，阻塞，死亡 进程就是程序的一次执行，而线程可以理解为进程中的执行的一段程序片段。用一点文词说就是，每个进程都有独立的代码和数据空间(进程上下文);而线程可以看成是轻量级的进程。一般来讲(不使用特殊技术)，同一进程所产生的线
Java模拟生产者/消费者问题，验证线程通过同步等方法解决死锁问题代码
06-11
以下是一个使用Java多线程模拟生产者/消费者问题的示例代码，其中使用了同步方法来解决可能出现的死锁问题： ``` public class ProducerConsumerExample { private static Queue<Integer> buffer = new LinkedList...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值