黑马程序员_日记17_Java多线程（七）

最新推荐文章于 2015-04-12 23:46:05 发布
最新推荐文章于 2015-04-12 23:46:05 发布
阅读量426 收藏
点赞数 1
分类专栏： 黑马Java基础学习笔记 文章标签： 线程间通信 生产者和消费者 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itheima_1llt/article/details/44732195
版权

　——- android培训、java培训、期待与您交流！ ———-

线程间通信

线程间的通信：
其实就是多个线程操作同一个资源，但是操作的动作不同。

一、我的示例

这是我写的关于线程间通信的示例。

本示例需要定义三个类：
1 资源类Resource
2 输入类Input
3 输出类Output

步骤：
1 先写出基本代码
2 找安全问题并修改

1 初级代码

//本类定义的资源是，人的数据
class Resource
{
    private String name;//私有化人的名字
    private String sex;//私有化人的性别

    //提供set方法，来访问name和sex
    public void set(String name,String sex)
    {
        this.name = name;
        this.sex = sex;
    }

    //提供get方法来打印name和sex
    public void get()
    {
        System.out.println(name+"......"+sex);
    }
}

//本类定义的是往共享数据中存数据
class Input implements Runnable
{
    //私有化共享数据
    private Resource r;

    //利用重载构造函数来传递共享数据
    Input(Resource r)
    {
        this.r = r;
    }

    //首先覆盖run方法,定义功能：一种情况存入男人，另一种情况存入女人
    public void run()
    {
        //定义一个布尔变量来区分两种情况
        boolean flag_in = true;

        while(true)
        {
                if(flag_in)//如果为真，则存入男，张三
                {
                    r.set("张三","男");
                    flag_in = false;
                }
                else//如果为假，则存入女，李丽
                {
                    r.set("李丽",".........女");
                    flag_in = true;
                }
        }
    }
}

//本类定义的是从共享数据中取数据
class Output implements Runnable
{
    private Resource r;

    Output(Resource r)
    {
        this.r = r;
    }

    public void run()
    {
        while(true)
            r.get();
    }
}



class MyInputOutputDemo 
{
    public static void main(String[] args) 
    {
        //建立资源对象
        Resource r = new Resource();

        //建立实现了runnable接口的对象
        Input in = new Input(r);
        Output out = new Output(r);

        //建立线程对象
        Thread t1 = new Thread(in);//输入线程
        Thread t2 = new Thread(out);//输出线程

        //启动线程
        t1.start();
        t2.start();
    }
}

运行结果中存在：
李丽……男
张三……………女
说明了线程通信存在安全问题
什么原因呢？？
因为在存数据的同时，还可以取数据。

2 修正代码

下面利用上次所学的解决安全问题的办法

//本类定义的资源是，人的数据
class Resource
{
    private String name;//私有化人的名字
    private String sex;//私有化人的性别
    private boolean flag = false;//设置监视器来控制输入输出

    //提供set方法，来访问name和sex
    public void set(String name,String sex)
    {
        if(!flag)//监视器为假的时候，存入数据
        {
            this.name = name;
            this.sex = sex;
            flag = true;
        }
    }

    //提供get方法来打印name和sex
    public void get()
    {
        if(flag)//监视器为真的时候取出数据
        {
            System.out.println(name+"......"+sex);
            flag = false;
        }
    }
}

//本类定义的是往共享数据中存数据
class Input implements Runnable
{
    //私有化共享数据
    private Resource r;

    //利用重载构造函数来传递共享数据
    Input(Resource r)
    {
        this.r = r;
    }

    //首先覆盖run方法,定义功能：一种情况存入男人，另一种情况存入女人
    public void run()
    {
        //定义一个布尔变量来区分两种情况
        boolean flag_in = true;

        while(true)
        {
                if(flag_in)//如果为真，则存入男，张三
                {
                    r.set("张三","男");
                    flag_in = false;
                }
                else//如果为假，则存入女，李丽
                {
                    r.set("李丽",".........女");
                    flag_in = true;
                }
        }
    }
}

//本类定义的是从共享数据中取数据
class Output implements Runnable
{
    private Resource r;

    Output(Resource r)
    {
        this.r = r;
    }

    public void run()
    {
        while(true)
            r.get();
    }
}



class MyInputOutputDemo 
{
    public static void main(String[] args) 
    {
        //建立资源对象
        Resource r = new Resource();

        //建立实习了runnable接口的对象
        Input in = new Input(r);
        Output out = new Output(r);

        //建立线程对象
        Thread t1 = new Thread(in);//输入线程
        Thread t2 = new Thread(out);//输出线程

        //启动线程
        t1.start();
        t2.start();
    }
}

运行结果显示：
通过给资源增加监视器，已经解决了存取错误的一个问题。

但是还存在这样的问题：
张三……男
张三……男
张三……男
李丽……………女

这说明还存在安全问题。
这是由于CPU切换造成的。

正确的情况应该是交替输出：
存一个取一个。

3 等待唤醒机智解决安全问题的代码

那么该怎么解决呢？？？
Java提供了等待唤醒机制。
下面改动一下程序。

//本类定义的资源是，人的数据
class Resource
{
    private String name;//私有化人的名字
    private String sex;//私有化人的性别
    private boolean flag = false;//设置监视器来控制输入输出

    //提供set方法，来访问name和sex
    public synchronized void set(String name,String sex)
    {
        if(flag)//监视器为真的时候，等待
        {
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
            }
        }

            this.name = name;
            this.sex = sex;
            flag = true;
            this.notify();//唤醒线程池中的第一个线程
    }

    //提供get方法来打印name和sex
    public synchronized void get()
    {
        if(!flag)//监视器为假的时候，线程等待
        {
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
            }
        }
                System.out.println(name+"......"+sex);
                flag = false;
                this.notify();//唤醒线程池中的第一个线程
    }
}

//本类定义的是往共享数据中存数据
class Input implements Runnable
{
    //私有化共享数据
    private Resource r;

    //利用重载构造函数来传递共享数据
    Input(Resource r)
    {
        this.r = r;
    }

    //首先覆盖run方法,定义功能：一种情况存入男人，另一种情况存入女人
    public void run()
    {
        //定义一个布尔变量来区分两种情况
        boolean flag_in = true;

        while(true)
        {
                if(flag_in)//如果为真，则存入男，张三
                {
                    r.set("张三","男");
                    flag_in = false;
                }
                else//如果为假，则存入女，李丽
                {
                    r.set("李丽",".........女");
                    flag_in = true;
                }
        }
    }
}

//本类定义的是从共享数据中取数据
class Output implements Runnable
{
    private Resource r;

    Output(Resource r)
    {
        this.r = r;
    }

    public void run()
    {
        while(true)
            r.get();
    }
}



class MyInputOutputDemo 
{
    public static void main(String[] args) 
    {
        //建立资源对象
        Resource r = new Resource();
        /*
        //建立实现了runnable接口的对象
        Input in = new Input(r);
        Output out = new Output(r);

        //建立线程对象
        Thread t1 = new Thread(in);//输入线程
        Thread t2 = new Thread(out);//输出线程

        //启动线程
        t1.start();
        t2.start();
        */

        //上面的6行代码啊可以简化为2行
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();

    }
}

运行结果显示成功解决输入线程和输出线程通信的安全问题。

二、生产者消费者问题

生产者消费者问题

一、先处理只有1个生产者和1个消费者的情况

二、再处理2个生产者和2个消费者的情况

对于一、
步骤：
1 建立一个资源类，包含成员变量（商品名称，商品编号、监视器）
和方法（设置商品名称和商品编号）

2 建立生产者类，实现Runnable接口，覆盖run方法

3 建立消费者类，实现Runnable接口，覆盖run方法

① 1个消费者线程和1个生产者线程安全运行的代码

//1个消费者线程和1个生产者线程
class Resource
{
    private String name;//商品名称
    private int count=1;//商品编号
    private boolean flag = false;//监视器

    //设置商品名称，编号自动加1
    public synchronized void set(String name)
    {
        if(flag)//如果资源监视器为真，那么调用本方法的对象等待
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
            }
                this.name = name;
                 count++;
                 System.out.println(Thread.currentThread().getName()+"..."+name+"...生产者...编号:"+count);
                flag = true;
                this.notify();//唤醒线程池中的第一个线程
    }

    //获取商品名称和编号
    public synchronized void get()
    {
        if(!flag)//如果资源监视器为假，那么调用本方法的对象等待
        try
        {
            this.wait();
        }
        catch (Exception e)
        {
        }
            System.out.println(Thread.currentThread().getName()+"..."+name+"....消费者.........编号："+count);
            flag = false;
            this.notify();//唤醒线程池中的第一线程
    }

}

class Producer implements Runnable
{
    private Resource r;

    //利用传递引用类型变量和构造函数避免造成初始化对象不唯一
    Producer(Resource r)
    {
        this.r =r;
    }

    public void run()
    {
        while(true)
            r.set("商品");
    }

}

class Consumer implements Runnable
{
    private Resource r;

    Consumer(Resource r)
    {
        this.r = r;
    }

    public void run()
    {
        while(true)
            r.get();
    }
}






class MyProducerConsumerDemo 
{
    public static void main(String[] args) 
    {
        //建立资源对象
        Resource r =new Resource();

        //建立生产者对象
        Producer p =new Producer(r);

        //建立消费者对象
        Consumer c = new Consumer(r);

        //建立生产者线程
        Thread tp1 = new Thread(p);

        //建立消费者线程
        Thread cp1 = new Thread(c);

        //启动生产者线程
        tp1.start();

        //启动消费者线程
        cp1.start();


        //简化代码
        //new Thread(new Producer(r)).start();
        //new Thread(new Consumer(r)).start();

    }
}

② 2个生产者和2个消费这正常运行的代码

//两个生产者和两个消费者线程
class Resource
{
    private String name;//商品名称
    private int count=1;//商品编号
    private boolean flag = false;//监视器

    //设置商品名称，编号自动加1
    public synchronized void set(String name)
    {
        //if(flag)//如果资源监视器为真，那么调用本方法的对象等待
        while(flag)
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
            }
                this.name = name;
                 count++;
                 System.out.println(Thread.currentThread().getName()+"..."+name+"...生产者...编号:"+count);
                flag = true;
                this.notifyAll();//唤醒线程池中的第一个线程
    }

    //获取商品名称和编号
    public synchronized void get()
    {

        //if(!flag)//如果资源监视器为假，那么调用本方法的对象等待
        while(!flag)
        try
        {
            this.wait();
        }
        catch (Exception e)
        {
        }
            System.out.println(Thread.currentThread().getName()+"..."+name+"....消费者.........编号："+count);
            flag = false;
            this.notifyAll();//唤醒线程池中的第一线程
    }

}

class Producer implements Runnable
{
    private Resource r;

    //利用传递引用类型变量和构造函数避免造成初始化对象不唯一
    Producer(Resource r)
    {
        this.r =r;
    }

    public void run()
    {
        while(true)
            r.set("商品");
    }

}

class Consumer implements Runnable
{
    private Resource r;

    Consumer(Resource r)
    {
        this.r = r;
    }

    public void run()
    {
        while(true)
            r.get();
    }
}






class MyProducerConsumerDemo 
{
    public static void main(String[] args) 
    {
        //建立资源对象
        Resource r =new Resource();

        //建立生产者对象
        Producer p =new Producer(r);

        //建立消费者对象
        Consumer c = new Consumer(r);

        //建立生产者线程
        Thread tp1 = new Thread(p);
        Thread tp2 = new Thread(p);

        //建立消费者线程
        Thread cp1 = new Thread(c);
        Thread cp2 = new Thread(c);

        //启动生产者线程
        tp1.start();
        tp2.start();

        //启动消费者线程
        cp1.start();
        cp2.start();
    }
}

运行结果出现：
生产一次，消费2次的情况。
Thread-1…商品…生产者…编号:359
Thread-3…商品….消费者………编号：359
Thread-2…商品….消费者………编号：359

生产2次，消费1次的情况。
Thread-1…商品…生产者…编号:3424
Thread-0…商品…生产者…编号:3425
Thread-3…商品….消费者………编号：3425

分析和总结

这说明，原来在1个生产者和1个消费者安全
但在2个生产者和2个消费者就不安全了。

为什么会这样呢？？
因为在用if语句判断的时候，当线程被唤醒后，它并没有再判断flag,
而是直接执行下一条语句，所以我们可以把if改成while。

if(flag)//如果资源监视器为真，那么调用本方法的对象等待

改成while(flag)的时候，运行结果为：
Thread-0…商品…生产者…编号:2
Thread-3…商品….消费者………编号：2
Thread-1…商品…生产者…编号:3
Thread-3…商品….消费者………编号：3
Thread-0…商品…生产者…编号:4

如图所示：
这里写图片描述
4个线程全部处于睡眠状态，不再打印。

这又是因为睡眠呢？？
原因是notify唤醒的都是线程池中的第一个线程，
这就导致了被唤醒的线程不一定是对方的线程。
而当唤醒的是本方线程时候，线程就全部陷入了等待。
该怎么解决呢？？
可以用notifyAll();

运行结果显示安全问题被解决！

小结：
在多个生产者和多个消费者的情况下，
用while+notifyAll();

回到未来2020
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员_日记15_Java多线程（五）
itheima_1llt的专栏
03-28 375
——- android培训、java培训、期待与您交流！ ———-单例设计模式只允许建立一个对象的设计模式称之为单例设计模式。饿汉式饿汉式：是指已加载该类，就立刻建立对象。//饿汉式 class HungryManSingle { //建立引用，终身指向饿汉式创建的对象 private static final HungryManSingle s = new HungryManSin
黑马程序员_日记13_Java多线程（三）
itheima_1llt的专栏
03-27 458
——- android培训、java培训、期待与您交流！ ———-一、多线程的安全问题1 概述在前面的例子中我把ticket–和打印语句分开的时候， 出现了一张票被卖4词的情况。 当我把这两条语句合并的时候，再把票额调高到30000时候， 多次测试，也会偶尔出现一张票被卖2次以上。 这就说明多线程共享数据存在安全问题。……票额到30000,CPU利用率都飙升到97了！(⊙﹏⊙)b下面我们通过
黑马程序员_日记16_Java多线程（六）
itheima_1llt的专栏
03-28 513
——- android培训、java培训、期待与您交流！ ———-死锁一、基本概念死锁是什么呢？ 两个线程分别持有一个资源， 并同时请求得到对方的资源。 在这种情况下产生的不正常情况就叫做死锁。死锁在什么情况下会发生呢？ 死锁在同步嵌套同步的情况下会发生。 至少有2把锁，才会产生死锁。二、死锁实例1首先，以前面售票的例子展示一下死锁。class Ticket implements Runn
黑马程序员_日记14_Java多线程(四)
itheima_1llt的专栏
03-28 388
——- android培训、java培训、期待与您交流！ ———-同步函数的锁是this同步函数用的是哪一个锁呢？通过下列程序进行验证。使用两个线程来买票。 一个线程在同步代码块中。 一个线程在同步函数中。 都在执行买票动作。class Ticket implements Runnable { private int tick = 100; Object obj = new
黑马程序员_Java_多线程
wdcs23的专栏
01-22 317
Java多线程学习日记，对多线程做了概述，同时分析了线程安全问题、死锁、线程间通讯。
黑马程序员_日记19_Java多线程（九）
itheima_1llt的专栏
04-01 397
——- android培训、java培训、期待与您交流！ ———-1 停止线程原理：让run方法结束。而run方法中通常定义循环结构，所以就是控制住循环结构就可以了。stop方法已经过时了。如何控制循环结构？？ 1 定义结束标记 2 当线程处于了冻结状态，没有执行标记，程序一样无法结束。 这时可以循环，正常退出冻结状态，或者强制结束冻结状态。 强制结束冻结状
黑马程序员_JAVA_多线程
a874508605的专栏
11-20 353
一、进程与线程： 进程：正在运行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径 ，或者叫一个控制单元。   线程，就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。   其实更细节说明jvm启动不止一个线程，还有负责垃圾回收机制的线程。   线程都有自己的默认名称，也可以通过setName()方法，或者通过构造方法来给线程设置自定义的
黑马程序员_张孝祥_Java多线程与并发库
05-17
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
java_Thread.rar_java 多线程_java多线程
09-21
Java多线程实例，是学习java多线程的好方法
黑马程序员–Java多线程讲解笔记
12-22
当一个进程中线程有多个时，是多线程。 　为什么要用多线程 　1，让计算机"同时"做多件事情，节约时间。 　2，后台运行程序，提高程序的运行效率.。 　3，多线程可以让程序"同时"处理多个事情。 　4，...
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
黑马程序员_张孝祥_Java多线程与并发库，视频+代码+资料
xy.rar_Java 下载器_java 多线程下载
09-22
java下载器,可实现下载、暂停等功能，有新建对话框，能实现多线程下载
黑马程序员_日记8_JavaSE阶段性习题练习及复习
itheima_1llt的专栏
03-25 3301
——- android培训、java培训、期待与您交流！ ———-JAVASE阶段性习题练习及复习这篇博客主要是把毕老师出的前四大练习题全部做了一遍，经我反复测试和修改后写得一些JAVASE基础总结。 练习一 已知学生成绩以100分为满分，共分5个等级：A,B,C,D,E。 90～100为等级A，80～89为等级B，70～79为等级C， 60～69为等级D，0～59为等级E。
黑马程序员_日记27_JavaString类型的数字排序问题
itheima_1llt的专栏
04-11 2555
——- android培训、java培训、期待与您交流！ ———-输入一int型的数字字符串 用空格间隔，从小到大排序后，以字符串返回。 “12 0 99 -7 30 4 100 13” 要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。“-7 0 4 12 13 30 99 100”分析： 1 用split方法把字符串切割成String[]类型的数组。 2 把String[]数组
黑马程序员_日记25_Java两个字符串的最大相同子串
itheima_1llt的专栏
04-11 681
——- android培训、java培训、期待与您交流！ ———-/* 获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。 "abcwerthelloyuiodef" "cvhellobnm"模拟一下： 第一趟： 最大子串：cvhellobnm ↑--------↑ 在长字符串中查找 abcwerthelloyuiodef ↑---
黑马程序员_日记33_Java迭代器基本使用
itheima_1llt的专栏
04-12 662
——- android培训、java培训、期待与您交流！ ———-迭代器Iterator测试查阅API，得到迭代器的基本常识： 对 collection 进行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同： 迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection
黑马程序员_日记26_Java字典序排序练习
itheima_1llt的专栏
04-11 632
——- android培训、java培训、期待与您交流！ ———-对字符串中字符进行自然顺序排序。 例如，”vcz1bdAa+cs”–>abccdsvz 思路： 1 把字符串变成字符数组 2 对数组进行排序 3 找到字符数组中’a’第一次出现的位置找到 4 计算要转换的字符个数 5 把字符数组变成字符串import java.util.Arrays; class StringSortD
黑马程序员_日记2--Java数组
itheima_1llt的专栏
03-19 614
——- android培训、java培训、期待与您交流！ ———-数组复习总结一、数组的定义数组的概念所谓数组，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序
java 多线程应用_java多线程的应用
最新发布
05-30
Java 多线程是 Java 语言中一个非常重要的特性，它允许程序在同一时间内执行多个任务。这种能力使得 Java 应用程序可以更高效地利用计算机的 CPU，从而提高应用程序的性能。Java 多线程的应用非常广泛，下面是一些...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值