java毕向东学习笔记——day12

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量267 收藏 1
点赞数 1
分类专栏： java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zck_1997/article/details/77778617
版权

一 多线程通讯

  1. 多线程通讯的意思其实很简单，就是不同于以往的两个线程做同样的事情操作同一个对象——比如day11的火车售票，而是多个线程执行对于同一个对象执行不同的事情，比如说今天的对同一个对象中的数据，一个线程负责输入，一个线程负责输出；
  2. 多线程通讯由于不同线程做的事情不同，因此需要多个对象实现Runnable接口并重写run方法；
  3. 多线程应当注意的仍然是安全问题，因此在需要同步的地方慎重判断，本例由于操作的还是同一个对象中的数据，因此两个run方法所在的Input和Output的同步函数可以用操作对象当做锁，从而实现同一把锁，避免安全隐患；
  4. 今天的代码中要实现的是输入数据，而后立刻输出，因此引入了flag进行判断输入的数据是否已经输出，以及wait方法和notify方法用于暂停/唤醒——输入/输出线程；
  5. 如果数据已经输出则输入数据，如果数据未输出则暂停当前的输入线程，唤醒输出线程，转到输出线程进行输出，在输出线程中判断数据是否已经输出，如果没有，则输出数据，如果已经输出，则暂停输出线程，唤醒输入线程进行输入；
  6. 以上的话过于繁琐，还是看两个版本的代码来的快。。。
/*
    输入一个姓名和性别，然后用另一个线程输出
*/

class Resource{
    String name;
    String sex;
    boolean flag = false; //用来作为判定输入是否输出的标识
}

class Input implements Runnable{
    private Resource res;
    Input(Resource res){
        this.res = res;
    }
    public void run(){
        int x = 0;
        while(true){
            //两个线程用同一个对象锁
            synchronized(res){
                if (res.flag)
                    try{
                        res.wait();
                    }catch(InterruptedException e){

                    }
                if(x==0){
                    res.name = "张三";
                    res.sex = "男";
                }else {
                    res.name = "WWW";
                    res.sex = "woman";
                }
                x = (x+1)%2;
                res.flag = true;
                res.notify();
            }   
        }
    }
}

class Output implements Runnable{
    private Resource res;
    Output(Resource res){
        this.res = res;
    }
    public void run(){
        while(true){
            //两个线程用同一个对象锁
            synchronized(res){
                if(!res.flag)
                    try{
                        res.wait();
                    }catch(InterruptedException e){

                    }
                System.out.println(res.name+"......"+res.sex);
                res.flag = false;
                res.notify();
            }
        }
    }
}

class ThreadCommunicationDemo{
    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();
    }
}

下面的是优化版本

/**
    用一个线程输入姓名和性别，用另一个线程输出姓名和性别的
    优化版本！
    @author zck;
    @version V1.1;
*/

class Resource{
    private String name;
    private String sex;
    private boolean flag = false; //用来作为判定输入是否已经输出的标识

    public synchronized void setNameSex(String name,String sex){
        if (flag){
            try{
                this.wait();
            }catch(InterruptedException e){

            }
        }   
        this.name = name;
        this.sex = sex;
        flag = true;
        notify();
    }

    public synchronized void getNameSex(){
        if (!flag){
            try{
                this.wait();
            }catch(InterruptedException e){

            }
        }
        System.out.println(this.name+"......"+this.sex);
        flag = false;
        notify();
    }
}

class Input implements Runnable{
    private Resource res;
    Input(Resource res){
        this.res = res;
    }
    public void run(){
        int x = 0;
        while(true){
                if(x==0){
                    res.setNameSex("张三","男");
                }else {
                    res.setNameSex("WWW","woman");
                }
                x = (x+1)%2;
        }   
    }
}


class Output implements Runnable{
    private Resource res;
    Output(Resource res){
        this.res = res;
    }
    public void run(){
        while(true){
                res.getNameSex();
        }
    }
}


class ThreadCommunicationDemo2{                //优化版本
    public static void main(String[] args){
        Resource r = new Resource();
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
    }
}

二 多线程通讯——生产者消费者

  1. 在多个线程运行时，有多个生产者，多个消费者；

  2. 在屏幕上打印输出时，有时候会出现生产两次却只消费了一次的情况，这与预期的生产一次消费一次不符合，这种安全隐患来自于flag的if判断，因为只判定一次，当生产线程1通过if判断时，执行完wait语句就失去了执行权，然后接下来消费线程1执行，然后生产线程2执行（因为此时flag是false），当生产线程2执行完时，flag变成了true，但是由于生产线程1已经在之前中通过了if判断，当生产线程1获得执行权时，就会再生产一次；
    打印结果：
    生产商品1
    消费商品1
    生产商品2
    生产商品3
    消费商品3
    改进方法就是将if换成while判断

  3. 还有一种安全隐患就是notify叫醒的线程池里本类线程，就会出现叫醒生产线程1叫醒生产线程2，然后所有线程都挂了（都进入wait状态）；处理方式就是改notify为notifyAll，干脆全叫醒，就不会出现所有线程一起挂在那儿的情况了；

class ProducerConsumerDemo{
    public static void main(String[] args){
        ProducerConsumer pc = new ProducerConsumer();

        Producer pro = new Producer(pc);
        Consumer con = new Consumer(pc);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class ProducerConsumer{
    private String name;
    private int count = 1;
    private boolean flag = false;

    public synchronized void setName(String name){
        while(true){
            while(flag){
                try{
                    wait();
                }catch(InterruptedException e){

                }
            }
            this.name = name+"..."+count++;
            System.out.println(Thread.currentThread().getName()+"---生产---"+this.name);
            flag = true;
            this.notifyAll();
        }   
    }

    public synchronized void getName(){
        while(true){    
            while(!flag){
                try{
                    wait();
                }catch(InterruptedException e){

                }
            }
            System.out.println(Thread.currentThread().getName()+"---消费-----"+this.name);
            flag = false;
            this.notifyAll();
        }   
    }
}

class Producer implements Runnable{
    ProducerConsumer pc;
    Producer(ProducerConsumer pc){
        this.pc = pc;
    }
    public void run(){
        pc.setName("商品");
    }
}

class Consumer implements Runnable{
    ProducerConsumer pc;
    Consumer(ProducerConsumer pc){
        this.pc = pc;
    }
    public void run(){
        pc.getName();
    }
}

下面是java5.0改进版本
1. 引入了lock代替synchronized,condition对象的await代替wait,signal和signalAll代替notify和notifyAll;

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2{
    public static void main(String[] args){
        ProducerConsumer pc = new ProducerConsumer();

        Producer pro = new Producer(pc);
        Consumer con = new Consumer(pc);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class ProducerConsumer{
    private String name;
    private int count = 1;
    private boolean flag = false;

    private Lock lock = new ReentrantLock();
    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();

    public void setName(String name) throws InterruptedException{
        lock.lock();
        try{
            while(flag){
                condition_pro.await();
            }
            this.name = name+"..."+count++;
            System.out.println(Thread.currentThread().getName()+"---生产---"+this.name);
            flag = true;
            condition_con.signalAll();
        }finally{       
            lock.unlock();
        }   
    }

    public void getName() throws InterruptedException{  
        lock.lock();
        try{
            while(!flag){
                condition_con.await();
            }
            System.out.println(Thread.currentThread().getName()+"---消费-----"+this.name);
            flag = false;
            condition_pro.signalAll();
        }finally{
            lock.unlock();
        }   
    }
}

class Producer implements Runnable{
    ProducerConsumer pc;
    Producer(ProducerConsumer pc){
        this.pc = pc;
    }
    public void run(){
        while(true){
            try{
                pc.setName("商品");
            }catch(InterruptedException e){

            }
        }   
    }
}

class Consumer implements Runnable{
    ProducerConsumer pc;
    Consumer(ProducerConsumer pc){
        this.pc = pc;
    }
    public void run(){
        while(true){
            try{
                pc.getName();
            }catch(InterruptedException e){

            }   
        }   
    }
}

三 中断线程

  1. 有时候线程处于冻结状态后无法正常读取唤醒标记，这时候就需要外力强制中断线程的冻结状态；
  2. Thread类就提供了interrupt方法，强制唤醒线程（好比把被催眠的人一砖头砸醒），但是这样会导致wait或者sleep抛出异常（因为被砖头砸醒不比正常唤醒，会受伤的，，）；
class InterruptThreadDemo{
    public static void main(String[] args){
        int num = 0;

        TestThread tt = new TestThread();
        Thread t1 = new Thread(tt);
        Thread t2 = new Thread(tt);

        t1.start();
        t2.start();

        while(true){
            if(num++ == 60){
                //tt.changeFlag();
                //强制唤醒了t1和t2线程
                t1.interrupt();   
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"..."+num);
        }
    }
}

class TestThread implements Runnable{
    private boolean flag = true;

    public synchronized void run(){
        while(flag){
            try{
                wait();
            }catch(InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"InterruptedException");
                //结束循环实则为结束进程
                flag = false;
            }
            System.out.println(Thread.currentThread().getName()+"run.....");
        }
    }

    public void changeFlag(){
        flag = false;
    }
}

四 守护线程

  1. 可以通过Thread 的setDaemon方法将一些线程设置为守护线程；
  2. 守护线程的设置应当在线程执行前；
  3. 守护线程可视为后台线程，当所有前台线程都结束时，守护线程自动结束；
  4. 这意味着守护线程即使被wait了，也没必要唤醒后再结束，只要前台线程跑完即可；
class InterruptThreadDemo{
    public static void main(String[] args){
        int num = 0;

        TestThread tt = new TestThread();
        Thread t1 = new Thread(tt);
        Thread t2 = new Thread(tt);

        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();

        while(true){
            if(num++ == 60){
                //tt.changeFlag();
                //强制唤醒了t1和t2线程
                //t1.interrupt();   
                //t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"..."+num);
        }
    }
}

class TestThread implements Runnable{
    private boolean flag = true;

    public void run(){
        while(flag){
            System.out.println(Thread.currentThread().getName()+"run.....");
        }
    }

    public void changeFlag(){
        flag = false;
    }
}

五 join、yield方法和优先级

  1. join方法实则为暂停当前线程，优先执行调用join方法的线程，直到调用join方法的线程结束后再执行当前线程；
  2. toString方法可以查看线程名称，优先级，以及所在线程组；
  3. 优先级为1——10，代表被cpu执行的概率；
  4. 通过setPriority(Thread.MAX/MIN/NORM_PRIORITY)设置三个不同的优先级，对应10/1/5;
  5. yield方法是暂停当前线程，执行其他线程；
class JoinDemo{
    public static void main(String[] args) throws InterruptedException{
        Join jo = new Join();

        Thread t1 = new Thread(jo);
        Thread t2 = new Thread(jo);

        t1.start();
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.start();
        //t1.join();
        for(int x = 0;x<80;x++){
            System.out.println(Thread.currentThread().toString()+"....."+x);
        }
    }
}

class Join implements Runnable{
    public void run(){
        for (int x = 0;x<70;x++){
            System.out.println(Thread.currentThread().toString()+"..."+x);
            //Thread.yield();
        }
    }
}
zck_1997
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java学习笔记——毕向东视频day06
pennyLee020的博客
01-14 498
3.1.1理解面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程 •强调的是功能行为 面向对象 •将功能封装进对象，强调具备了功能的对象。 面向对象是基于面向过程的。 3.1.2 面向对象的特点 是一种符合人们思考习惯的思想 可以将复杂的事情简单化 将程序员从执行者转换成了指挥者 完成需求时： •先要去找具有所需的功
java各知识点详细总结(毕向东笔记整理)
01-30
java各知识点详细总结(毕向东笔记整理)。第一章：编程基础 3-11 第二章：数组 11 -31 第三章：面向对象程序开发 31 -74 第四章：异常机制 74 -89 第五章：多线程技术 89 -122122122 第六章：常用类 API 122API 122 ...
java毕向东学习笔记——day01
zck_1997的博客
07-20 326
java基础学习
java毕向东学习笔记——day09
zck_1997的博客
08-20 495
java毕向东学习笔记——day09内部类 外部类要访问内部类，必需先建立内部类的对象； 内部类可以直接访问外部类； class Outer{ int x = 1; class Inner{ int x = 2; void function(){ int x = 3;
java毕向东学习笔记——day08
zck_1997的博客
08-11 234
java毕向东学习笔记——day08多态 父类引用指向子类对象; 提高了代码的复用性; 类与类之间需要有继承关系; 当父类引用指向子类对象时，即Animal c = new Cat()——其实是类型提升，在需要子类对象特有的方法时，可以转换为子类类型:即 Cat q = (Cat)c; instanceof关键字，判断对象的类型，比如if(c instanceof Cat)； 需要注意的是，当方法并
java毕向东学习笔记——day07
zck_1997的博客
08-07 183
1.继承 子类继承父类的特性； class A extends B class B extends C java中支持多层继承，但不支持多继承 2.super关键字 super用法与 this 类似，但是super代表父类引用，this代表当前类引用 3.方法的重写 如果子类继承父类后，对父类中的方法内容不满意，则可以进行重写 class Dad{ vo
java毕向东学习笔记——day10
zck_1997的博客
08-26 279
异常处理语句中的注意事项 finally常用于一定要执行的语句，或者用于关闭资源； catch语句用于处理异常，如果没有catch则异常就未被处理，如果该异常是检测时异常，则需要声明； 子类在重写父类的方法时，只可以抛出父类异常的子类或者父类异常，假如确实自己的程序产生了新异常，则应该在内部try….catch处理； 异常练习的代码/* 异常的练习 */interface Shape{
java毕向东学习笔记——day06
zck_1997的博客
08-01 218
1.static 关键字 static 是一个修饰符，用来修饰成员变量和成员函数； static 修饰的成员变量称为静态成员变量 / 类变量 ; 普通的成员变量在创建对象时建立，存储在堆中，生命周期与对象相同； 而static 修饰的成员变量，在类加载时加载，存储在方法区 / 共享区, 生命周期与类相同； 此外一般的方法也存储在方法区； static 修饰的成员变量，是为了节省
java毕向东学习笔记——day02~day05
zck_1997的博客
07-31 358
day02 //1.数据类型转换 short a = 5; a = a+2; /* * 这个就会出现编译错误，因为short类型的a变量是2个字节，在执行a+2时，a自动 * 升级为4个字节的整型，无法再赋值给2个字节的short类型变量。 * / a = (short)(a+2); //这样才是合理的，即为强制类型转换 a +=
java学习笔记——毕向东视频day01
pennyLee020的博客
12-22 960
day01没啥好说的，就是一些基本概念和环境搭建，之前在慕课网已经搭好了，看视频也是用的1.50x，在这里就做一些简单摘要把。 摘自课程PPT的内容： 什么是软件？ •软件：一系列按照特定顺序组织的计算机数据和指令的集合。 •常见的软件： •系统软件： •如：DOS，windows，Linux等。 •应用软件： •如：扫雷，迅雷，QQ等。 什么是开发？ •制作软件 人机交互
毕向东java经典学习笔记word版
11-02
【毕向东Java经典学习笔记Word版】是一份深入讲解Java编程语言的学习资料，由知名IT教育专家毕向东编撰。这份笔记以其系统性、实践性和深度广度深受Java初学者和进阶者的喜爱。毕向东作为Java教育领域的权威人士，他...
毕向东Java笔记
07-22
### 毕向东Java笔记知识点总结 #### 第一章：编程基础 1. **Java的特性和优势**： - **简单性**：Java的设计哲学是“使编程变得简单”。 - **面向对象**：Java完全支持面向对象编程概念如封装、继承和多态。 - ...
最全毕向东java笔记
03-02
传智播客毕向东java笔记，比较全面，毕向东老师上课的代码，总结基本都有，分享给大家。
毕向东Java SE视频教程整理笔记
03-08
### 毕向东Java SE视频教程整理笔记 #### 第一章：编程基础 - **Java的特性和优势**：Java语言具有多种特性，包括简单性、面向对象、可移植性（一次编写，到处运行）、高性能、分布式、动态性、多线程、安全性以及...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 183
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 527
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 520
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 563
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值