黑马程序员_JAVA笔记12——多线程间通讯

最新推荐文章于 2015-10-24 21:56:42 发布
最新推荐文章于 2015-10-24 21:56:42 发布
阅读量451 收藏
点赞数
分类专栏： JAVA基础笔记 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011453546/article/details/10830579
版权
-------  android培训、 java培训、期待与您交流！ ----------
1、线程间通讯,其实就是多个线程在操作同一资源，但是操作动作不同
class Res
{
        String name;
        String sex;
}
class Input implements Runnable
{
        private Res r ;
        Input(Res r)
        {
                this.r = r;
        }
        public void run()
        {
                int x= 0;
                while(true)
                {
                         synchroized(r)
                        {
                        if(x==0)
                        {
                        r.name = "mike";
                        r.sex = "man";
                        }
                        else
                        {
                        r.name = "丽丽";
                        r.sex = "女";
                        }
                        x = (x+1)%2;
                        }
                }
        }
}
class Output implements Runnable
{
        private Res r;
        Output(Res r)
        {
                this.r = r ;
        }
        public void run()
        {
                while(true)
                {
                         synchroized(r)//此时的r，与上一个锁的r是同一个，表示这两个synchroized(r)是同一个锁
                        {
                System.out.println("name"+r.name+
"         sex"+r.sex
);
               }
                }
        }
}
class InputOutputDemo
{
        public static void main(String[] args)
        {
                Res r = new Res();
                Thread t1 = new Thread(new Input(r));
                Thread t2 = new Thread(new Output(r));
                t1.start();
                t2.start();
        }
}

知识理解：在多个synchroized（对象）中，只要这些对象是同一个对象，那么这些synchroized就表示是同一个锁。而括号中的对象，并不限定是谁的对象，只要唯一就可以。

wait()    notify()   notifyAll()用法：
都使用在同步中（锁中、监视器中），因为对持有监视器的线程操作。所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中，因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被同一个锁notify唤醒。不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任何对象，所以可以被任意对象调用的方法定义在Object类中。


class Res
{
        String name;
        String sex;
        boolean flag = false;
}
class Input implements Runnable
{
        private Res r ;
        Input(Res r)
        {
                this.r = r;
        }
        public void run()
        {
                int x= 0;
                while(true)
                {
                        
                         synchroized(r)
   {
                        if(r.flag)
                        {
//wait()在定义时抛异常了，因此这里需要try catch 不能抛
                      try{r. wait();}catch（Exception e){}  
                        }
    if(x==0)
                        {
                        r.name = "mike";
                        r.sex = "man";
                        }
                        else
                        {
                        r.name = "丽丽";
                        r.sex = "女";
                        }

                        x = (x+1)%2;
    r.flag=true;
    r.notify();//默认唤醒第一个wait()的线程
                        }
                }
        }
}
class Output implements Runnable
{
        private Res r;
        Output(Res r)
        {
                this.r = r ;
        }
        public void run()
        {
                while(true)
                {
                         synchroized(r)//此时的r，与上一个锁的r是同一个，表示这两个synchroized(r)是同一个锁
                        {
                         if(!r.flag)
                        {
                               try{r. wait();}catch（Exception e){}
                        }
                System.out.println("name"+r.name+"         sex"+r.sex);
    r.flag = false;
    r.notify();//默认唤醒第一个wait()的线程
               }
                }
        }
}
class InputOutputDemo
{
        public static void main(String[] args)
        {
                Res r = new Res();
                Thread t1 = new Thread(new Input(r));
                Thread t2 = new Thread(new Output(r));
                t1.start();
                t2.start();
        }
}

2、生产者消费者问题，有 多个消费者多个生产者时必须用while循环，必须notifyAll.
原因:如下例子t1  t2  生产者    t3  t4   消费者，执行后：
明确一点：当线程在wait后，再次notify时，会继续执行wait语句后面的语句。
在这里，while 作用是在t1 t2都wait后，再次notify时，重新判断flag是否复合条件。同时，while的负作用就是会导致所有线程都进入wait状态，因此必须唤醒线程，用notifyAll();如果用notify()仅能唤醒一个线程，如果该线程不复合条件，那么又陷入全部线程等待的情况，因此用notifyAll();
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(Exception e){}
                }
                this.name = name+"................."+count++;
                System.out.println(Thread.currentThread().getName()+".....生产者......."+this.name);
                flag = true;
                  this.notifyAll();
        }
        public synchronized void out()
        {
                while(!flag)
                {
                         try{this.wait();}catch(Exception e){}
                }
                System.out.println(Thread.currentThread().getName()+"........消费者......."+this.name);
                flag = true;
                this.notifyAll();
        }
}
class Producer implements Runnable
{
        Resource res;
        Producer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        res.set("producer");
                }
        }
}
class Consumer implements Runnable
{
        Resource res;
        Producer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        res.out();
                }
        }
}
class ProConDemo
{
        public static void main(String[] args)
        {
                Resource res = new Resource();
                Producer p = new Producer(res);
                Consumer c = new Consumer(res);
                Thread t1 = new Thread(p);
                Thread t2 = new Thread(p);
                Thread t3 = new Thread(c);
                Thread t4 = new Thread(c);
                t1.start();
                t2.start();
                t3.start();
                t4.start();

 }
}


jdk1.5版本后，提供了多线程升级解决方案，将同步synchronized替换成了lock。
接口Lock，类ReentrantLock实现接口，Condition中await  signal 代替wait  notify
Lock中定义了方法：void lock()   获取锁         void unlock()   释放锁
                                Condition  newCondition()    返回绑定到此Lock实例的Condition对象
Condition中定义了方法：await()等待   signal()唤醒一个线程     signalAll()唤醒所有线程
新特性：一个锁上可以有多个condition对象.（而一个synchronized只有一个wait notify）
如下红色代码：实现了pro唤醒con的操作，con唤醒了pro的操作。

import java.util.concurrent.locks.*;
class Resource
{
        private String name;
        private int count=1;
        private boolean flag = false;
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
       //  private Condition condition_pro = new lock.newCondition();
        //private Condition condition_con = new lock.newCondition();

        public synchronized void set(String name) throws InterruptedException
        {
                lock.lock();
                try
                {
                        while(flag)
                {
                        condition.await();
     //condition_pro.await();
                }
                this.name = name+"................."+count++;
                System.out.println(Thread.currentThread().getName()+".....生产者......."+this.name);

                flag = true;
                condition.signalAll();
      //  condition_con.signal();
                }
               finally
                {
                    lock.unlock();//释放锁的操作一定要执行
                }
        }
        public synchronized void out() throws InterruptedException
        {
                lock.lock();
                try
                }
                while(!flag)
                {
                        condition.await();
     //conditidon_con.await();
                }
                System.out.println(Thread.currentThread().getName()+"........消费者......."+this.name);
                flag = true;  
      condition.signalAll();//唤醒所有线程
     // condition_pro.signal();
                }
                finally
                {
                        lock.unlock();
                }
        }
}
class Producer implements Runnable
{
        Resource res;
        Producer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        try//set(String name)抛异常了
                        {
                            res.set("producer");
                        }
                        catch(InterruptedException e)
                        {

                        }
                }
        }
}
class Consumer implements Runnable
{
        Resource res;
        Producer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        try//out()抛异常了
                        {
                            res.out();
                        }
                        catch(InterruptedException e)
                        {
                        }
                }
        }
}
class ProConDemo
{
        public static void main(String[] args)
        {
                Resource res = new Resource();
                Producer p = new Producer(res);
                Consumer c = new Consumer(res);
                Thread t1 = new Thread(p);
                Thread t2 = new Thread(p);
                Thread t3 = new Thread(c);
                Thread t4 = new Thread(c);
                t1.start();
                t2.start();
                t3.start();
                t4.start();



        }
}


3、停止线程
stop方法已经过时，如何停止线程？只有一种方法，run方法结束。
开启多线程运行，运行代码通常是循环结构，因此只要控制住循环就可以让run方法结束，也就是线程结束
特殊情况：当线程处于冻结状态，就不会读取到标记，线程就不会结束。
当没有指定方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。
Thread类中提供了该方法interrupt();
注意：使用了interrupt(),会抛异常InterruptedException   因此需要  try  catch(InterruptedException e) 处理，在处理语句中操作标记， 如下的flag=false,让线程回到运行状态。
class StopThread implements Runnable
{
        private boolean flag = true;
        public synchronized void run()
        {
                while(flag)
                {
                        try
                        {
                        wait();
                        }
                        catch(InterruptedException e)
                        {
                                System.out.println(Thread.currentThread().getName()+".....Exception");
                                 flag = false;
                        }
                }
        }
        public void changeFlag()
        {
                flag = false;
        }
}
class StopThreadDemo
{
        public static void main(String[] args)
        {
                StopThread st =new StopThread();
                Thread t1 = new Thread(st);
                Thread t2 = new Thread(st);
                t1.start();
                t2.start();
                while(true)
                {
                        if(num++==60)
                        {
                                //st.changeFlag();
                                t1.interrupt();//强行中断t1冻结状态
                                break;
                        }
                        System.out.println(Thread.curentThread().getName()+".........."+num);
                }
        }
}

4、Thread类中的常见方法
一：poublic final void setDaemon(boolean on);     不抛异常
守护线程：将该线程标记为守护线程，当正在运行的线程都是守护线程时，JVM退出，该方法必须在启动线程前调用。
                t1.setDaemon(true)//此时t1已成为守护线程，在t1.start()前调用
                t2.setDaemon(true)//此时t2已成为守护线程，在t2.start()前调用
                t1.start();
                t2.start();
在上面例子中，若t1 t2为守护线程，则main线程结束时，t1 t2也结束了；如果t1 t2不是守护线程，在main线程结束后，t1 t2会毅然执行。

二：public final void join() 
throw  InterruptedException


class Demo implements Runnable
{
        public void run()
        {
                for(int x=0;x<70;x++)
                {
                        System.out.println(Thread.currendThread().getName()+x);
                }
        }
}
class JoinDemo
{
        public static void main(String[] args)
        {
                Demo d = new Demo();
                Thread t1 = new Thread(d);
                Thread t2 = new Thread(d);
                t1.start();
                t1.join();//执行到这里时，主线程进入冻结状态，t1夺得执行权，t1执行，主线程等待t1结束后，再继续执行
                t2.start();
                //   t1.join();若放在这里，主线程释放执行权并进入冻结状态，而这时t
1 t2都有执行资格，因此t1 t2交替执行，但是，当 t1执行完毕后，主线程进入运行状态（不管t2是否执行完，若t2还没结束，则主线程与t2交替执行）。（这里，若t1  wait了，那么主线程也就over了，所以才有方法interrupt）
              for(int x=0;x<80;x++)
                {
                        System.out.println("main"+x);
                }
                System.out.println("over");
        }
}

三：void  toString(),翻译该线程的字符创表示形式，包括线程名称、优先级和线程组。
线程组：谁开启了线程谁就是线程组，如main开启了t1 t2，那么t1 t2属于main线程组。
优先级：代表抢夺资源的频率，谁优先级高，CPU就执行谁频繁一些。线程优先级默认是5级，包括主线程。
优先级范围：1——10级
            static int MAX_PRIORITY:线程可以具有的最高优先级     10级
            static int MIN_PRIORITY:线程可以具有的最低优先级        1级
            static int NORM_PRIORITY:分配给线程的默认优先级        5级
设置优先级：

                Demo d = new Demo();
                Thread t1 = new Thread(d);
                Thread t2 = new Thread(d);
                t1.start();
                 t1.setPriority(Thread.MAX_PRIORITY);//表示t1执行频繁一些，但其他线程仍执行。
                t2.start();

四：static void yield()    暂停当前正在执行的线程对象，并执行其他线程。

class Demo implements Runnable
{
        public void run()
        {
                for(int x=0;x<70;x++)
                {
                        System.out.println(Thread.currendThread().getName()+x);
                        Thread.yield();//表示执行到该语句的线程，临时释放执行权一小会儿，然后继续抢夺执行权执行。
                }
        }
}
class JoinDemo
{
        public static void main(String[] args)
        {
                Demo d = new Demo();
                Thread t1 = new Thread(d);
                Thread t2 = new Thread(d);
                t1.start();
                t2.start();
              for(int x=0;x<80;x++)
                {
                        System.out.println("main"+x);
                }
                System.out.println("over");
        }
}

5、实际开发过程中线程的写法
class ThreadTest
{
        public static void main(String[] args)
        {
                //有多个循环时，需要循环同时执行，可采用匿名内部类方式，以下三个循环同时执行
                  new Thread()
                {
                        public void run()
                        {
                                for(int i =0 ;i<199;i++)
                                {
                                        System.out.println(Thread.currentThread().getName()+x);
                                }
                        }
                }.start();//匿名内部类方式，创建线程


                 for(int i =0 ;i<199;i++)
                 {
                        System.out.println(Thread.currentThread().getName()+x);
                  }


                  Runnable r = new Runnable()
                {
                          public void run()
                        {
                                for(int i =0 ;i<199;i++)
                                {
                                        System.out.println(Thread.currentThread().getName()+x);
                                }
                        }
                }
                new Thread(r).start();
        }
}
五里一徘徊孔雀东南飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java 多线程】Java 线程间通信
吃货小跟班的博客
03-07 468
本文简单总结线程间通信的方式：方法一：等待／通知机制wait + notify + notifyAll的方式方法二：通过管道进行线程间通信使用Java给我们提供的管道流（pipeStream），在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读数据， 在Java 的JDK中提供了4个类来使线程间可以进行通信： 1）PipedInputStream 和 PipedOut
Java——多线程之线程间通信
用代码征服天下
12-02 159
Java多线系列文章是Java多线程的详解介绍，对多线程还不熟悉的同学可以先去看一下我的这篇博客Java基础系列3：多线程超详细总结，这篇博客从宏观层面介绍了多线程的整体概况，接下来的几篇文章是对多线程的深入剖析。 线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体。线程间的通信就是成为整体的必用方案之一，可以说，使线程间进行通信后，系统之间的交互性会更强大，在大大提高...
黑马程序员_JAVA笔记11——多线程
u011453546的专栏
09-01 573
------- android培训、java培训、期待与您交流！ ---------- 1、多线程     进程：是一个正在执行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。     线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。     一个进程中至少有一个线程。     java VM  启动的时候会有一个进程 ja
黑马程序员——Java练习笔记——多线程
ring_8677的专栏
05-17 381
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-1.进程,线程的概念 进程：正在执行的程序 线程：进程中一个负责程序执行的控制单元（执行路径） 2.多线程的好处和弊端 好处：解决了多部分代码同时运行的问题 弊端：降低了运行效率 原因：多个应用程序同时执行都是CPU在做着快速切换完成的，这个切
黑马程序员Java笔记——多线程篇
晴耕雨读
08-15 544
----------- android培训、java培训、java学习型技术博客、期待与您交流！ --------- 关键词： 多线程的秘密花园、 Thread先生与Runnable小姐、同步 引子：     现实生活中，我们可以同时做很多事情：在写代码的同时可以听音乐；在做饭的同时可以打电话等……。在使用计算机的时候也可以一边听歌，一边玩游戏。那么我们Java是否支持多线程呢
黑马程序员java学习笔记——IO流
魏天翔的博客
06-08 510
IO流     概述     流的特点     IO流用于处理设备之间的数据传输；     java对数据的操作是通过流的方式；     java用于操作留的对象都放在IO包中；     流按操作数据分为两种：字节流和字符流；     按流向分为：输入流和输出流；     字符流对相融合了编码表。     流常用基类     字节流的抽象基类：输入流InputS
黑马程序员——Java要点笔记——面向对象（三）
u013114489的博客
07-13 476
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- day08 04-面向对象-单例设计模式-概述&体现 1、设计模式：来源与建筑行业。是一种对问题进行有效解决的方式。其实，它是一种思想。 2、单例设计模式（单个实例，单个对象，单块堆内存）        解决的问题：就是可以保证一个类在内存中的对象唯一性。 3、用全静态也可以实现，
黑马程序员——Java中 多线程笔记
bayueqinglian的专栏
06-28 401
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一、多线程概述 进程：正在运行的程序，是系统进行资源分配和调用的独立单位。  每一个进程都有它自己的内存空间和系统资源。       线程：是进程中的单个顺序控制流，是一条执行路径  一个进程如果只有一条执行路径，则称为单线程程序。  一个进程如果有多条执行
黑马程序员————多线程练习与笔记
W_lilong的博客
10-24 371
------- android培训、java培训、期待与您交流！ ----------  多线程 一，线程的２种创建方式 创建线程的第一种方式：继承Thread ，由子类复写run方法。 步骤：  1，定义类继承Thread类；   2，目的是复写run方法，将要让线程运行的代码都存储到run方法中； 3，通过创建Thread类的子类对象，创建线程对象；  4
黑马程序员_JAVA笔记24——网络编程（练习）
u011453546的专栏
09-02 994
------- android培训、java培训、期待与您交流！ ---------- 1、练习--TCP客户端并发登陆 /* 客户端通过键盘录入用户名，服务端对这个用户名进行校验。 如果该用户存在，在服务端显示XXX，已登陆。并在客户端显示XXX，欢迎光临 如果该用户不存在，在服务端显示XXX，尝试登陆。并在客户端显示XXX，该用户不存在 最多就登陆三次。 */
黑马程序员_JAVA笔记23——网络编程
u011453546的专栏
09-02 909
------- android培训、java培训、期待与您交流！ ---------- 一、网络编程     1、网络模型         OSI参考模型，数据封包，发送数据时，从上往下每一层都加一层信息，最后形成数据封包；到物理层时就传递给目标。目标接收到数据包后，从下往上依次拆包，每拆一包每层都获得相关层信息。                 应用层           
黑马程序员_JAVA笔记02——标识符、进制、变量、运算符、if和switch语句
u011453546的专栏
09-01 812
------- android培训、java培训、期待与您交流！ ---------- 1  Java语言基础组成：关键字、标识符、注释、常量变量、运算符、语句、函数、数组     a  标识符：在程序中自定义的一些名称。         组成：由26个字母大小写，数字0-9，_和$组成。         规则：数字不可以开头，不可以使用关键字，严格区分大小写。
黑马程序员_JAVA笔记21——IO流
u011453546的专栏
09-02 810
------- android培训、java培训、期待与您交流！ ---------- 一、对象的序列化（对象的持久化，就是把对象存储到硬盘上，方便今后使用)     操作对象,被操作的对象需要实现Serializable（标记接口，没有方法的接口）         ObjectInputStream         ObjectOutputStream      
黑马程序员_JAVA笔记22——GUI
u011453546的专栏
09-02 782
------- android培训、java培训、期待与您交流！ ---------- 一、GUI  （图形用户界面）         JAVA为GUI提供的对象都存在java.Awt和javax.Swing两个包中。         java.Awt:Abstract Window ToolKit(抽象工具包），需要调用本地系统方法实现功能，属于重量级控件。（比较依赖于平台）
黑马程序员_JAVA笔记19——IO流
u011453546的专栏
09-01 746
------- android培训、java培训、期待与您交流！ ---------- 1、IO流用来处理设备之间的数据传输     java对数据的操作是通过流的方式     java 用于操作流的对象都在IO包中     流按操作数据分为两种，字节流和字符流     流按流向分为：输入流，输出流     字节流的抽象基类             input
黑马程序员_JAVA笔记14——集合框架（List、HashSet、TreeSet）
u011453546的专栏
09-01 694
------- android培训、java培训、期待与您交流！ ---------- 1、为什么出现集合类，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最长哟昂的一种方式。         数组与集合类都是容器，有何不同？数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。数组只
黑马程序员_JAVA笔记15——集合框架（泛型）
u011453546的专栏
09-01 649
------- android培训、java培训、期待与您交流！ ---------- 1、泛型：JDK1.5后出现的新特性，用于解决安全问题，是一个安全机制。 好处：         将运行时期出现问题ClassCastException异常，转移到编译时期，方便于程序员解决问题，让运行时期问题减少，提高安全。         避免了强制类型转换的麻烦 泛型理解：数组在
黑马程序员_JAVA笔记06——面向对象2(static、main函数、对象)
u011453546的专栏
09-01 636
------- android培训、java培训、期待与您交流！ ---------- 1  static关键字，是一个修饰符，用于修饰成员变量和成员函数。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用，格式：类名.静态成员。         修饰成员变量：在生成对象时，不被修饰的成员变量，存放在堆内存中。对于多个对象中存在的共同数据，可以用
获取上传的路径_JAVA学习笔记——fileUpload文件上传
最新发布
05-17
在Java中获取上传的文件路径可以使用HttpServletRequest对象的getServletContext()方法获取当前应用程序的上下文路径，再加上上传文件的相对路径即可。 例如，假设文件上传的相对路径为“/upload”，则可以使用以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值