5-1-Java多线程-练习-妖的出现和解决

最新推荐文章于 2025-08-13 20:25:08 发布
原创 最新推荐文章于 2025-08-13 20:25:08 发布 · 429 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程 #重构

本文探讨了多线程环境下共享资源的同步问题，通过不同方法解决了线程间的数据竞争和有序输出问题，包括使用synchronized关键字、等待唤醒机制、重构资源类以及采用Lock和Condition接口。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

妖的出现和解决

需求

  • 资源有姓名和性别。
  • 两个线程，
  • 一个负责给姓名和性别赋值，

  • 一个负责获取姓名和性别的值。

    1. 要求1，运行一下，解决程序的 “妖”的问题。
      分析过程：
      加入同步，必须保证同一个锁，解决妖的问题。

    2. 要求2，实现正确数据的间隔输出 如
      张飞–男
      rose–女女女
      张飞–男
      rose–女女女

    3. 要求3，对代码进行重构。
      将name，sex私有化，资源类提供对其访问的方法。

    4. 要求4，将程序改成JDK1.5的Lock Condition接口。

代码示例-需要分析的代码

代码


//描述资源。
class Resource
{
    String name;
    String sex;
}
//赋值线程任务
class Input implements Runnable
{
    private Resource r;
    //  private Object obj = new Object();
    Input(Resource r)//任务一初始化就必须有要处理的资源。
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {

            if(x==0)
            {
                r.name = "张飞";
                r.sex = "男";
            }
            else
            {
                r.name = "rose";
                r.sex = "女女女女";
            }

            x = (x+1)%2;//实现切换。
        }
    }
}
//获取值线程任务
class Output implements Runnable
{
    private Resource r ;
    //  private Object obj = new Object();
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            System.out.println(r.name+"....."+r.sex);
        }
    }
}

class ThreadTest2
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();

    }
}

　运行结果

张飞.....男
rose.....女女女女
rose.....女女女女
张飞.....女女女女
张飞.....女女女女
rose.....男
rose.....女女女女
rose.....女女女女
张飞.....女女女女
rose.....女女女女
rose.....女女女女
张飞.....男
张飞.....男
rose.....女女女女

　分析

操作共享数据 name 和 sex

假设在–>处切换CPU执行权

if(x==0)
{
    r.name = "张飞";
    -->
    r.sex = "男";
}
else
{
    r.name = "rose";
    -->
    r.sex = "女女女女";
}

解决问题1

要求1，运行一下，解决程序的 “妖”的问题。
分析过程：
加入同步，必须保证同一个锁，解决妖的问题

代码示例

注意使用resouce做锁.(同步输入输出两个动作)

class Resource
{
    String name;
    String sex;
}
//赋值线程任务
class Input implements Runnable
{
    private Resource r;
    //  private Object obj = new Object();
    Input(Resource r)//任务一初始化就必须有要处理的资源。
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)
            {
                if(x==0)
                {
                    r.name = "张飞";
                    r.sex = "男";
                }
                else
                {
                    r.name = "rose";
                    r.sex = "女女女女";
                }
            }
            x = (x+1)%2;//实现切换。
        }
    }
}
//获取值线程任务
class Output implements Runnable
{
    private Resource r ;
    //  private Object obj = new Object();
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
           synchronized(r)
            {
                System.out.println(r.name+"....."+r.sex);
            }
        }
    }
}

class ThreadTest2
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();

    }
}

运行结果

rose.....女女女女
rose.....女女女女
rose.....女女女女
rose.....女女女女
rose.....女女女女
rose.....女女女女
rose.....女女女女
rose.....女女女女
张飞.....男
张飞.....男
张飞.....男
张飞.....男
张飞.....男
张飞.....男
张飞.....男
张飞.....男

解决问题2

  1. 要求2，实现正确数据的间隔输出 如
    张飞–男
    rose–女女女
    张飞–男
    rose–女女女

代码

使用等待唤醒机制,使用flag作为判断是否等待

class Resource
{
    String name;
    String sex;
    //定义标记，
    boolean flag = false;

}
//赋值线程任务
class Input implements Runnable
{
    private Resource r;
    //  private Object obj = new Object();
    Input(Resource r)//任务一初始化就必须有要处理的资源。
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)
            {
                if(r.flag)
                    try{r.wait();}catch(InterruptedException e){}
                if(x==0)
                {
                    r.name = "张飞";
                    r.sex = "男";
                }
                else
                {
                    r.name = "rose";
                    r.sex = "女女女女";
                }

                r.flag = true;
                r.notify();
            }
            x = (x+1)%2;//实现切换。
        }
    }
}
//获取值线程任务
class Output implements Runnable
{
    private Resource r ;
    //  private Object obj = new Object();
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r)
            {
                if(!r.flag)
                    try{r.wait();}catch(InterruptedException e){}
                System.out.println(r.name+"....."+r.sex);
                r.flag = false;
                r.notify();
            }
        }
    }
}

class ThreadTest2_2
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();

    }
}

解决问题3

  1. 要求3，对代码进行重构。
    将name，sex私有化，资源类提供对其访问的方法。

代码示例

class Resource
{
    private String name;
    private String sex;
    //定义标记，
    private boolean flag = false;

    //赋值功能。
    public synchronized void set(String name,String sex)
    {
        if(flag)
            try{this.wait();}catch(InterruptedException e){}
        this.name = name;
        this.sex = sex;
        flag = true;
        this.notify();
    }

    //获取值。
    public synchronized void out()
    {
        if(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(name+"------"+sex);
        flag = false;
        this.notify();
    }

}
//赋值线程任务
class Input implements Runnable
{
    private Resource r;
    Input(Resource r)//任务一初始化就必须有要处理的资源。
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            if(x==0)
            {
                r.set("张飞","男");
            }
            else
            {
                r.set("rose","女女女女");
            }
            x = (x+1)%2;//实现切换。
        }
    }
}
//获取值线程任务
class Output implements Runnable
{
    private Resource r ;
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class ThreadTest2_3
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();

    }
}

解决问题4

要求4，将程序改成JDK1.5的Lock Condition接口。
Lock替换了 同步函数或者同步代码块。
Condition替代了 监视器方法，将监视器方法从锁上分离出来，单独封装成Condition对象。

代码示例

class Resource
{
    private String name;
    private String sex;
    //定义标记，
    private boolean flag = false;

    //先创建锁对象。
    private final Lock lock = new ReentrantLock();

    //通过锁对象获取监视器对象。
    private Condition con = lock.newCondition();

    //赋值功能。
    public  void set(String name,String sex)
    {
        lock.lock();
        try{
            if(flag)
                try{con.await();}catch(InterruptedException e){}
            this.name = name;
            this.sex = sex;
            flag = true;
            con.signal();
        }finally{
            lock.unlock();
        }
    }

    //获取值。
    public  void out()
    {
        lock.lock();
        try{
            if(!flag)
                try{con.await();}catch(InterruptedException e){}
            System.out.println(name+"------"+sex);
            flag = false;
            con.signal();
        }finally{
            lock.unlock();
        }
    }

}
//赋值线程任务
class Input implements Runnable
{
    private Resource r;
    Input(Resource r)//任务一初始化就必须有要处理的资源。
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            if(x==0)
            {
                r.set("张飞","男");
            }
            else
            {
                r.set("rose","女女女女");
            }
            x = (x+1)%2;//实现切换。
        }
    }
}
//获取值线程任务
class Output implements Runnable
{
    private Resource r ;
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class ThreadTest2_4
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();

    }
}
Java多线程13 妖的出现
Stitch__的博客
08-22 210
需求： 资源有姓名和性别 两个线程 一个负责赋值/一个负责获取姓名和性别 要求1.运行代码，解决“妖”的问题 分析过程：典型的多线程安全问题 解决办法：加入同步，必须保证是同一个锁，解决妖的问题 要求二：实现数据的间隔输出 要求三：对代码进行重构。将name  sex 私有化，资源类对外提供方法 要求四：将程序改为 Lock  Condition   接口 代码： pack...
java-多线程的练习----妖,等待唤醒,代码重构,lock到condition
博客
11-20 160
1 需求 资源有姓名和性别。 两个线程，    一个负责给姓名和性别赋值，    一个负责获取姓名和性别的值。要求1，运行一下，解决程序的 "妖"的问题。要求2，实现正确数据的间隔输出 如 张飞--男rose--女女女张飞--男 rose--女女女要求3，对代码进行重构。    将name，sex私有化，资源类提供对其访问的方法。要求4，将程序改成JDK1.5的Lock Condit...
3-3-Java多线程-案例-银行存钱&同步函数
蛋子哥的博客
11-20 1175
银行存钱案例 两个客户到一个银行去存钱，每个客户一次存100，存三次。 问题：改程序是否有安全问题，如果有写出分析过程并定义解决方案 代码示例-未修改前代码class Bank{ private int sum; private Object obj = new Object(); public void add(int num) { sale(num
2-3-Java多线程-多线程内存图&线程名称
蛋子哥的博客
11-20 993
多线程内存图 多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。 进行方法的压栈和弹栈。 当执行线程的任务结束了，线程自动在栈内存这种释放了。 但是当所有的执行线程都结束了，进程就结束了 Java的并发采用的是共享内存模型（而非消息传递模型），线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。多个线程之间是不能直接传递数据交互的，它们之间的交互只
2-1-Java多线程-主线程的运行方式
蛋子哥的博客
11-20 953
>**当主线程在这个程序中执行时,如果遇到了一定业务逻辑导致执行时间过长,无法执行下面的程序,可不可以实现一个主线程负责执行其中一个,由另一个线程负责其他代码的执行,实现多部分代码同时执行.** >**这就是多线程技术可以解决的问题.** ## 如何创建线程 >创建线程的两种方式： 一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子
2-5-Java多线程-创建线程的Runnable接口方法及Thread源码解析
蛋子哥的博客
11-20 617
创建线程的Runnable接口方法 public interface Runnable Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。 设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如，Thread 类实现了 Runnable。激活的意思是说某个线程已启动并且尚未停止。 此外，
2-2-Java多线程-继承Thread类原理
蛋子哥的博客
11-20 564
继承Thread类原理继承Thread类 因为Thrad类描述线程事务，具备线程的基本功能 为什么不直接创建Thread类的对象 这么做没有错，但是该start方法调用的是thread类中的run方法这个方法不做任何操作就返回。更重要的是这个run方法中并没有定义我们需要让线程执行的代码。 创建线程的目的是 是为了建立单独的执行路径，让多部分代码实现同时执行，也就是说线程创建并执行需要给
3-2-Java多线程-案例-单例设计模式出现的问题
蛋子哥的博客
11-20 467
单例设计模式出现的问题代码示例class Demo implements Runnable{ public void run() { Single.getInstance(); } }饿汉式 饿汉式多线程并发没有问题 class Single { private static final Single SINGLE = new Single();
3-5-Java多线程-案例-生产者&消费者wait&notify
蛋子哥的博客
11-20 453
生产者＆消费者问题 多线程中最为常见的应用案例 生产者消费者问题 生产和消费同时执行，需要多线程 但是执行的任务却不相同，处理的资源却是相同的；线程间通信．描述一下资源 描述一下生产者，因为其具备自己的任务 描述一下消费者，因为其具备自己的任务 代码示例-1代码 /*描述资源*/ /* * 属性：商品名称和编号 * 行为：对名称赋值，获取商品 * */ class Resource{ pri
3-1-Java多线程-案例-售票&线程状态
蛋子哥的博客
11-20 437
售票案例线程状态 售票的动作需要被多个线程同时执行，所以要使用多线程技术 代码示例-线程不安全　代码 class Ticket implements Runnable{ private int tickets = 20; /*售票动作需要被多线程执行，那就是线程任务代码*/ private Object object = new Object(); public
4-1-JDK1.5-Lock接口
蛋子哥的博客
11-20 436
java.util.concurrent.locks JDK1.5以后提供了多生产多消费的解决方案. Lock接口:比同步有更多的操作.Lock():获取锁,unlock:释放锁;提供了一个更加面向对象的锁,在该锁中提供了更多的显式的锁操作.替代同步 在将旧锁替换为新锁后,那么锁上的监视器方法(wait,notify,notifyALL),也应该替换成新锁的监视器方法.而JD
6-1-Java多线程-多线程细节问题
蛋子哥的博客
11-20 414
多线程细节问题sleep方法和wait方法的异同点？相同点: 让线程处于冻结状态. 不同点: sleep必须指定时间 wait可以指定时间也可以不指定时间 sleep时间到,线程处于临时阻塞状态或者运行态 wait如果没有时间,必须通过notify或者notifyAll唤醒 sleep不一定非要定义在同步中 wait必须定义在同步中
3-4-Java多线程-案例-死锁
蛋子哥的博客
11-20 386
死锁同步的另一个弊端：情况之一：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。 这时容易引发一种现象：死锁。 这种情况能避免就避免掉。//Thread-0 synchronized(obj1) { -->thread-0 obj1 synchronized(obj2) { }} //Thread-1 synchronized(obj2) {
1-1-Java多线程-概念
蛋子哥的博客
11-20 330
定义进程 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程 线程是进程的一个实体,进程中的一个执行路径,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
2-4-Java多线程-多线程的异常
蛋子哥的博客
11-20 294
多线程的异常代码示例-1class DemoMul1 extends Thread{ private String name; public DemoMul1(String name) { this.name = name; } @Override public void run() { show(); try {
亚马逊优惠券视觉体系重构：颜色标签驱动的消费决策效率革命
2501_90930635的博客
08-12 649
亚马逊优惠券的视觉革命，本质是一场“信任传递效率”的竞争——谁能通过标签体系更快建立“价格可信+价值独特”的认知，谁就能在透明化市场中占据先机，对于卖家而言，这不仅是界面设计的调整，更是从“流量思维”到“用户资产思维”的转型契机。
开源WAF新标杆：雷池SafeLine用语义分析重构网站安全边界
最新发布
LT15171009269的博客
08-13 698
当个人或企业站点上线后面临的首要威胁往往来自网络攻击——据统计，超过60%的Web应用漏洞利用尝试在流量到达服务器前即被拦截。而国产开源项目雷池（SafeLine）正是为此而生：它以反向代理形态部署，在流量抵达网站前完成智能清洗，成为防御黑客渗透的第一道防线。
TinyVue表格重构性能优化详解
OpenTiny的博客
08-12 535
表格作为组件库高频使用的组件，它作为承载、展示和交互数据的核心载体,每一次卡顿都可能意味着时间的浪费与耐心的消磨。然而有小伙伴反馈说，表格组件树表数据滚动场景卡顿，偶尔会出现白屏现象，甚至会出现表头和表体滚动不同步的情况。后来据了解是小伙伴的机器性能较为普通，加上表格树表大数据虚拟滚动确实存在较大的性能瓶颈，存在大量的计算与dom操作。问题在性能较好的机器上被“屏蔽”了。打开 performance 面板点击面板内右上角设置按钮在 CPU 设置选项中点击弹出下拉面板。
Java多线程轮流打印1-100：实现与扩展
在Java中实现多线程轮流打印1-100的数字操作是一种常见的并发编程练习，它展示了如何利用多线程提高程序执行的效率和并行性。本文将深入探讨如何用Java实现这一任务，特别是针对单线程、双线程以及扩展到三线程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值