Java中的多线程（三）----死锁以及生产者消费者模式

最新推荐文章于 2025-03-17 15:29:01 发布

原创最新推荐文章于 2025-03-17 15:29:01 发布

· 629 阅读

1 ·

版权

文章标签：

#java #开发语言 #p2p

Java 专栏收录该内容

11 篇文章

订阅专栏

死锁的概念

“死锁”指的是：

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。

因此，某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁” 的问题。比如，“化妆线程”需要同时拥有“镜子对象”、“口红对象”才能运行同步块。那么，实际运行时，“小丫的化妆线程”拥有了“镜子对象”，“大丫的化妆线程”拥有了“口红对象”，都在互相等待对方释放资源，才能化妆。这样，两个线程就形成了互相等待，无法继续运行的“死锁状态”。

死锁案例演示

package 死锁;

/*
* 口红类
* */
class Lipstick{

}

/*
* 镜子类
* */
class Mirror{

}
/*
* 化妆类
* */
class Makeup extends Thread{
    private int flag;  //flag = 0;拿着口红  flag ！= 0；拿着镜子
    private String girlName;
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    public void setFlag(int flag) {
        this.flag = flag;
    }

    public void setGirlName(String girlName) {
        this.girlName = girlName;
    }

    @Override
    public void run() {
        this.doMakeup();
    }
    public void doMakeup(){
        if (flag == 0){
            synchronized (lipstick) {
                System.out.println(this.girlName + "拿着口红");
            }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){
                    System.out.println(this.girlName+"拿着镜子");
                }
        }else {
                synchronized (lipstick) {
                    System.out.println(this.girlName + "拿着镜子");
                }
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (mirror) {
                        System.out.println(this.girlName + "拿着口红");
                    }
        }
    }
}

public class MakeupTest {
    public static void main(String[] args) {
        Makeup makeup = new Makeup();
        makeup.setFlag(0);
        makeup.setGirlName("小红");
        Makeup makeup1 = new Makeup();
        makeup1.setFlag(1);
        makeup1.setGirlName("大黑");

        makeup.start();
        makeup1.start();
    }
}

this：可以理解是一个人去办很多事情，这些事情之间线程冲突，解决这个线程冲突的方法是设置当前对象锁；

字符串：很多人去办同一件事情，这件事情一次只能由一个人来处理，为了不让很多人之间线程冲突，需要设置常量串来实现同步；

Class：两个不同类之间互不影响，没有冲突，但是在同一个类的对象操作起来会出现线程冲突，就需要使用当前类的Class对象作为对象锁来解决线程冲突。

线程并发协作

多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。

角色介绍

什么是生产者？

生产者指的是负责生产数据的模块。

什么是消费者？

消费者指的是负责处理数据的模块。

什么是缓冲区？

消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

缓冲区是实现并发的核心，缓冲区的设置有两个好处：

实现线程的并发协作

有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况；同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离，解除了生产者与消费者之间的耦合。

解决忙闲不均，提高效率

生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费；消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据。

package 线程并发协作;

/*
* 创建馒头类
* */
class ManTou{
    private  int id;

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

    public int getId() {
        return id;
    }
}
/*
*定义缓冲区类
*/
class SyncStack{
//定义存放馒头的盒子
    private ManTou[] manTous = new ManTou[10];
    private int index;
    /*
    * 放馒头
    * */
    public synchronized void push(ManTou manTou) throws InterruptedException {
        while (this.index == this.manTous.length){
            this.wait();
        }
        this.notify();
        this.manTous[this.index] = manTou;
        this.index++;
    }

    /*
    * 取馒头
    * */
    public  synchronized ManTou pop(){
        while (this.index == 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.manTous[this.index];
    }
}

/*
* 定义生产者线程类
* */
class Produce extends Thread{
    private SyncStack ss;
    public Produce(SyncStack ss) {
        this.ss = ss;
    }

    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            System.out.println("生产馒头："+i);
            ManTou manTou  = new ManTou(i);
            try {
                this.ss.push(manTou);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}class Coustom extends Thread{
    private SyncStack ss;
    public Coustom(SyncStack ss) {
        this.ss = ss;
    }

    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            this.ss.pop();
            System.out.println("消费馒头："+i);
        }
    }
}
public class ProduceThread {
    public static void main(String[] args) {
        SyncStack syncStack = new SyncStack();
        new Produce(syncStack).start();
        new Coustom(syncStack).start();
    }

}

运行结果：