JAVA 学习模块十九： 线程间通信

最新推荐文章于 2023-07-11 18:56:16 发布
最新推荐文章于 2023-07-11 18:56:16 发布
阅读量847 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHAOLEI5911/article/details/52685042
版权

这里写图片描述

1.线程通信

/*
线程间通信：
多个线程，运行任务不一样，处理资源一样。



*/
//资源
class Resource
{
    String name;
    String sex;

}


//输入
class Input implements Runnable
{
    Resource r;
//  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 = "mk";
                r.sex = "n";
            }
            else
            {
                r.name = "ll";
                r.sex = "nv";
            }
            }
        }
        x = (x+1)%2;


    }
}


//输出
class Output implements Runnable

{
    Resource r;
//  Object obj = new Object();
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r)
            {
            r.name = "ll";
            r.sex = "n";
            System.out.println(r.sex);
        }
    }
    }
}

class ResourceDemo

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

    }
}

2.等待唤醒机制

/*
线程间通信：
多个线程，运行任务不一样，处理资源一样。


等待唤醒机制：
涉及的方法：
1.wait（）： 让线程处于冻结状态，被wait的线程会被存储到线程池中。
2.notify():唤醒线程池中的任意一个线程
3.notifyall（）： 唤醒线程池中的所有线程。

这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。必须要明确到底操作的是
那个锁上的线程。

为什么操作线程的方法  wait notify botifyall 定义在object中：
因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方法一定定义在object中。
*/
//资源
class Resource
{
    String name;
    String sex;
    Boolean flag;
}


//输入
class Input implements Runnable
{
    Resource r;
//  Object obj = new Object();//同步步骤一
    Input(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)//同步步骤二
            {
                if(r.flag)
                    r.wait();
            if(x ==0)
            {
                r.name = "mk";
                r.sex = "n";
            }
            else
            {
                r.name = "ll";
                r.sex = "nv";
            }
            }
            r.flag = true;
            r.notify();
        }
        x = (x+1)%2;


    }
}


//输出
class Output implements Runnable

{
    Resource r;
//  Object obj = new Object();
    Output(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r)
            {
                if(!r.flag)
                    r.wait();

            System.out.println(r.sex);
            r.flag = false;
            r.notify();
        }
    }
    }
}

class ResourceDemo

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

    }
}

3.生产一只卖一只

/*
线程间通信：
多个线程，运行任务不一样，处理资源一样。


等待唤醒机制：
题目： 生产者 消费者

*/
//资源
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name)
    {
        if(flag)
            try{this.wait();}catch(InterruptedException e){}
        this.name = name+count;
        count++;
        System.out.println("生产者"+this.name);
        flag = true;
        notify();
    }
    public synchronized void out()
    {
        if(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(this.name+"消费者");
        flag = false;
        notify();
    }
}

class Prod implements Runnable
{
    private Resource r;
    Prod(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
            r.set("ya");
    }
}

class Cos implements Runnable
{
    private Resource r;
    Cos(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class demo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Prod p =new Prod(r);
        Cos c = new Cos(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();

    }
}

4.多生产多消费

/*
线程间通信：
多个线程，运行任务不一样，处理资源一样。


等待唤醒机制：
题目： 生产者 消费者

2.多生产者，多消费者
if 判断标记，只有一次，会导致不该运行的线程运行了，出现数据错误的情况
while 判断标记，解决了现场获取执行权后，是否要运行！
notifyAll 解决了本方线程一定会唤醒对方线程，
notify  只能唤醒一个线程，如果本方唤醒本方，没有意义，而且while+notify 会导致死锁



*/
//资源
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name)
    {
        while(flag)
            try{this.wait();}catch(InterruptedException e){}
        this.name = name+count;
        count++;
        System.out.println("生产者"+this.name);
        flag = true;
        notifyAll();
    }
    public synchronized void out()
    {
        while(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(this.name+"消费者");
        flag = false;
        notifyAll();
    }
}

class Prod implements Runnable
{
    private Resource r;
    Prod(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
            r.set("ya");
    }
}

class Cos implements Runnable
{
    private Resource r;
    Cos(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class demo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Prod p =new Prod(r);
        Cos c = new Cos(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread();
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

5.lock 接口

jdk1.5以后将同步和锁风闸U那个成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。

/*
线程间通信：
多个线程，运行任务不一样，处理资源一样。


等待唤醒机制：
题目： 生产者 消费者

2.多生产者，多消费者

*/
//资源
import java.util.concurrent.locks.*;
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    Lock lock = new ReentrantLock();//创建一个锁对象
    Condition con = lock.newCondition();//通过已有的锁获得该锁上的监视器对象


    public void set(String name)
    {
        lock.lock();
        try
        {
            while(flag)
            try{con.await();}catch(InterruptedException e){}
        this.name = name+count;
        count++;
        System.out.println("生产者"+this.name);
        flag = true;
        con.signalAll();
        }
        finally
        {
            lock.unlock();
        }

    }
    public synchronized void out()
    {
        lock.lock();
        try
        {
            while(!flag)
            try{con.await();}catch(InterruptedException e){}
            System.out.println(this.name+"消费者");
            flag = false;
            con.signalAll();
        }
        finally
        {
            lock.unlock();
        }
    }
}

class Prod implements Runnable
{
    private Resource r;
    Prod(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
            r.set("ya");
    }
}

class Cos implements Runnable
{
    private Resource r;
    Cos(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class demo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Prod p =new Prod(r);
        Cos c = new Cos(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread();
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

二：

/*
线程间通信：
多个线程，运行任务不一样，处理资源一样。


等待唤醒机制：
题目： 生产者 消费者

2.多生产者，多消费者

*/
//资源
import java.util.concurrent.locks.*;
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    Lock lock = new ReentrantLock();//创建一个锁对象
//  Condition con = lock.newCondition();//通过已有的锁获得该锁上的监视器对象

    //通过已有的锁获取两组监视器，一组见识生产者，一组监视消费者
    Condition con1 = lock.newCondition();//生产者
    Condition con2 = lock.newCondition();//消费者

    public void set(String name)
    {
        lock.lock();
        try
        {
            while(flag)
            try{con1.await();}catch(InterruptedException e){}
        this.name = name+count;
        count++;
        System.out.println("生产者"+this.name);
        flag = true;
        con2.signal();
        }
        finally
        {
            lock.unlock();
        }

    }
    public synchronized void out()
    {
        lock.lock();
        try
        {
            while(!flag)
            try{con2.await();}catch(InterruptedException e){}
            System.out.println(this.name+"消费者");
            flag = false;
            con1.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}

class Prod implements Runnable
{
    private Resource r;
    Prod(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
            r.set("ya");
    }
}

class Cos implements Runnable
{
    private Resource r;
    Cos(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class demo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Prod p =new Prod(r);
        Cos c = new Cos(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread();
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

lock接口：出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成显式锁操作，同时更为灵活，可以一个锁上加多个监视器。
lock（） 获取锁
unlock（） 释放锁，通常需要定义在finally 代码块中

Condition接口： 出现代替了object 中的wait，notify ，notifyall 方法。
将这些监视器方法单独进行了封装，变成condition监视器对象，可以任意锁进行组合。
await（）
signal（）
signalall（）

/*

wait（） 和sleep() d的区别

1.wait 可以指定时间，也可以不指定，sleep必须指定
2.在同步中时对于cpu的执行权和锁的处理不一样
   wait（） 释放执行权，释放锁
   sleep（） 释放执行权，不释放锁

*/

6.停止线程

线程停止方法：
1.stop 方法
2.run 方法结束

怎么控制线程的任务结束呢？
任务中都有循环结构，只要控制循环就能结束任务，控制循环就用标记。 十四课！

just-天之蓝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解node child_process模块学习笔记
01-19
NodeJs是一个单进程的语言，不能像Java那样可以创建多线程来并发执行。当然在大部分情况下，NodeJs是不需要并发执行的，因为它是事件驱动性永不阻塞。但单进程也有个问题就是不能充分利用CPU的多核机制，根据前人的...
IntelliJ IDEA不同模块间类或对象如何通信/交流/传递/调用？
FisrtBqy的博客
03-09 1702
IntelliJ IDEA不同模块间类或对象如何通信/交流/传递/调用？ 在IntelliJ IDEA中如果直接调用不同模块下的内容，就会出现如下情况，不知读者是否也遇到了呢？ 细心的小伙伴可能会发现，在显红的类名Person下，智能的IntelliJ IDEA给出了提示： Add 'exports com.javamodule' directive to module-info.java 这里要说的是，就是它！单击它就对了！然后就大功告成了。 可能读者的IntelliJ IDEA没有给出这样的提示，不
java处理sql注入的方法：
wcw002500的博客
11-11 1041
方法1： String sql = " select * from s_org where org_name like :ssdqStr "; MapSqlParameterSource msq = new MapSqlParameterSource(); NamedParameterJdbcTemplate jdbc = new NamedParameterJdb...
java接口协议_超详细解读Java接口：模块通信协议以及默认方法和静态方法
weixin_39723010的博客
02-18 477
有不少学习Java的同学一直有个疑问，不仅在初学者中很普遍，连许多经验丰富的老手也很难表述清楚，那就是：Java接口到底是什么？来看看孙鑫老师的讲解，本文干货含量拉满，这可能是距离你深入理解Java接口最近的一次。本文选自《Java无难事：详解Java编程核心思想与技术》，文末了解本书详情。深入接口：通信双方的协议接口有一个重要的作用，就是作为模块与模块之间通信的协议。在软件领域，一直以来都希望能...
SpringBoot项目模块间通信的两种方式
qq_42108331的博客
07-11 1191
SpringBoot项目模块间通信的两种方式
Java通信方式总结
Mr.X
03-20 5635
Java通信方式总结 1 Java对象、方法间通信方式 1.1 值传递、引用传递 （1）值传递：将副本传递给方法，调用方法改变副本的值，但是并不改变原值 （2）引用传递：传递的是对象（或者变量）的引用，对其修改，会改变原值 从内存分配的角度讲解Java中只存在值传递，不存在引用传递 1.2 浅拷贝、深拷贝 （1）浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。 （2）深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容
JAVA_API1.6文档（中文）
04-12
java.applet 提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。 java.awt 包含用于创建用户界面和绘制图形图像的所有类。 java.awt.color 提供用于颜色空间的类。 java.awt.datatransfer ...
Java经典入门教程pdf完整版
09-03
简单地说,Java具有如下特点:简单的、面向对象、平台无关、多线程、分布式、安全、 晑性能、可靠的、解释型、自动垃圾回收等特点。 这里只解释一下平台无关和分布式,其余的在后面会逐步接触到 3:平台无关 所谓平台...
java版坦克大战源码-tankwar:坦克大战，java版联机对战游戏
06-05
项目融合了java基础知识栈、将设计模式应用在实战项目中，netty网络通信，实现了玩家间的交互 项目介绍 坦克大战联机对战游戏是马老师耗时数月精心打造的经典java项目，学习人次量达百万级别，配套完整视频19课时，...
java api最新7.0
10-26
java.applet 提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。 java.awt 包含用于创建用户界面和绘制图形图像的所有类。 java.awt.color 提供用于颜色空间的类。 java.awt.datatransfer 提供...
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
java maven 聚合项目 分模块 socket 双向通信实例demo
05-03
java maven 聚合项目 分模块实例; java socket 服务端与客户端，服务端主动发指令，客户端发送心跳包 实例demo。
深入理解Java 线程通信
08-19
主要介绍了Java 线程通信的的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
java 模块间怎么通信_java与c++模块之间的交互方法？
weixin_35835184的博客
02-13 1275
如果是单机的话, 确实可以使用 JNI.不过如果是各个模块之间在不同的主机上的话, 那么就需要进行网络通信了.下面我针对网络通信的方式来讲一下我的做法:针对于同步调用模式如果 Java 和 C++ 之间是相互调用关系的话, 例如 Java 调用 C++ 提供的服务, 那么一般可以看做是同步调用关系, 此时有如下几个方法:C++ 和 Java 之间使用 TCP 直接通信.这个方法最直接也相对地不是很...
Java9模块间的服务化详解
舒哥的blog
12-05 3003
Jdk9模块化实战入门 本章我们来到了Jdk9新增的最重要的一块内容——模块化。有过编程经验的人都不应该对模块化陌生， 无论是项目代码的组织、还是应用的拆分、架构的设计都渗透着模块化的思想，如今jdk9 不但本身已经模块化，且对我们创建模块化的应用程序提供了“本地原生”支持。模块化的程序提供了更高级的封装性与服务化特性。本章我们将学习：什么是模块化 jdk9 的模块化特性 如何构建模块化程序 面
超详细解读Java接口：模块通信协议以及默认方法和静态方法
程序猿DD
02-23 767
有不少学习Java的同学一直有个疑问，不仅在初学者中很普遍，连许多经验丰富的老手也很难表述清楚，那就是：Java接口到底是什么？来看看孙鑫老师的讲解，本文干货含量拉满，这可能是距离你深入理...
spring----模块之间的通讯问题
weixin_30896825的博客
06-03 695
Apache HttpClient Apache HttpClient 简介 HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上很著名的另外两个开源...
Java web项目系统间的通信的三种方式
林海静的博客
07-23 5948
一、Webservice： 基于soap协议，效率不高。常用于两个公司间的通信。可垮语言垮平台。 二、restful：形式：http+json。get请求或post请求传递json，URL不带参数，通过路径来描述。用spring中pathVarible从路径中来取值。 三、dubbo：避免服务调用的混乱，有一个统一的平台来发布、监控、管理服务。使用socket通信，传递的事二进制，效率高。有注...
java多线程拉取订单如何实现
最新发布
03-20
在Java中，可以使用多线程来实现订单的拉取。下面是一种可能的实现方式： ...7. 可以使用线程间的通信机制，例如使用阻塞队列来实现生产者-消费者模式，将拉取到的订单数据传递给其他模块进行处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值