【Java多线程编程核心技术】3.线程间通信 -笔记总结

最新推荐文章于 2024-02-02 17:53:44 发布

D.Chuan

最新推荐文章于 2024-02-02 17:53:44 发布

阅读量560

点赞数 2

分类专栏： Java多线程 Java多线程编程核心技术文章标签： java 多线程线程间通信生产者与消费者模式 ThreaLocal

本文链接：https://blog.csdn.net/YangDongChuan1995/article/details/78578337

版权

Java多线程同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

Java多线程编程核心技术

8 篇文章 3 订阅

订阅专栏

等待/通知机制

线程与线程之间不是独立的个体，他们彼此之间可以互相通信和协作。

不使用等待/通知机制实现线程通信

可以通过不停地while语句轮询机制来检测某一个条件，但这样特别耗费CPU资源。（轮询间隔时间小，更浪费CPU资源，如果间隔时间大，有可能获取不到想要的数据）

什么是等待/通知机制

餐厅里厨师与服务员之间的交互模式就属于等待/通知机制。
服务员去到菜的时间取决于厨师，所以服务员就有“等待（wait）”状态；
厨师做好菜放在“菜品传递台”上，其实就相当于一种“通知（notify）”；

等待/通知机制的实现

wait 使线程停止运行，notify 使停止的线程继续运行。

关键字 synchronized 可以将任何一个 Object 对象作为同步对象看待，而 Java 为每个 Object 都实现了 wait() 和 notify() 方法，他们必须用在被 synchronized 同步的 Object 的临界区内。

通过调用 wait 方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁。而 notify 操作可以唤醒一个因调用了 wait 方法而处于阻塞状态的线程，使其进入就绪状态。

被重新唤醒的线程会试图重新获得临界区的控制权，继续执行临界区内 wait 之后的代码。

wait 方法可以使调用该方法的线程释放共享资源的锁，从运行状态退出，进入等待状态，直到再次被唤醒。
notify() 方法可以随机唤醒等待对列中等待同一共享资源的一个线程，并使该线程退出等待状态，进入可运行状态。
notifyAll() 方法可以随机唤醒等待对列中等待同一共享资源的所有线程，并使这些线程退出等待状态，进入可运行状态。

敲黑板，划重点：wait（）立即释放锁，notify等线程执行完后再释放。

Java为每一个Object都实现了wait（）和notify（）方法，但它们必须用在被synchronized同步的Object的临界区，否则会抛出异常（IllegalMonitorStateException）
这里写图片描述
新创建一个线程对象后，在调用它的 start() 方法，系统会为此线程分配 CPU 资源，使其处于 Runnable（可运行）状态，如果线程抢占到 CPU 资源，此线程就会处于 Running （运行）状态

Runnable 和 Running 状态之间可以相互切换，因为线程有可能运行一段时间后，有其他优先级高的线程抢占了 CPU 资源，此时线程就从 Running 状态变成了 Runnable 状态。

线程进入 Runnable 状态大致有如下五种情况：
* 调用 sleep() 方法后经过的时间超过了指定的休眠时间
* 线程调用的阻塞 IO 已经返回，阻塞方法执行完毕
* 线程成功的获得了试图同步的监视器
* 线程正在等待某个通知，其他线程发出了通知
* 处于挂状态的线程调用了 resume 恢复方法

Blocked 是阻塞的意思，例如线程遇到一个 IO 操作，此时 CPU 处于空闲状态，可能会转而把 CPU 时间片分配给其他线程，这时也可以称为 “暂停”状态。Blocked 状态结束之后，进入 Runnable 状态，等待系统重新分配资源

出现阻塞状态的有如下五种情况：
* 线程调用 sleep 方法，主动放弃占用的处理器资源
* 线程调用了阻塞式 IO 方法，在该方法返回之前，该线程被阻塞
* 线程试图获得一个同步监视器，但该同步监视器正在被其他线程所持有
* 线程等待某个通知
* 程序调用了 suspend 方法将该线程挂起

run 方法运行结束后进入销毁阶段，整个线程执行完毕。

每个锁对象都是两个队列，一个是就绪队列，一个是阻塞队列
就绪队列：将要获得锁的线程，一个线程被唤醒后，才会进入就绪队列，等待CPU的调度
阻塞队列：被阻塞的线程，例如被wait后，就会进入阻塞队列

方法wait（）锁释放与notify（）锁不释放

当方法wait（）被执行后，锁被自动释放，但执行完notify（）方法，锁却不自动释放。

当interrupt方法遇到wait方法

当线程呈wait（）状态时，调用线程对象的interrupt（）方法会抛出如下异常

begin wait()
java.lang.InterruptedException
出现异常了，因为呈wait状态的线程被interrupt了！
     at java.lang.Object.wait(Native Method)
     at java.lang.Object.wait(Unknown Source)
     at service.Service.testMethod(Service.java:9)
     at extthread.ThreadA.run(ThreadA.java:17)

通知过早

如果通知过早，则会打乱程序正常的运行逻辑，例如在先notify（）后，再wait（），会导致线程一直处于wait状态，不会被通知。

等待wait的条件发生变化

public class Add {
     private String lock;
     public Add(String lock) {
          super();
          this.lock = lock;
     }
     public void add() {
          synchronized (lock) {
              ValueObject.list.add("anyString");
              lock.notifyAll();
          }
     }
}
public class Subtract {
     private String lock;
     public Subtract(String lock) {
          super();
          this.lock = lock;
     }
     public void subtract() {
          try {
              synchronized (lock) {
                   if (ValueObject.list.size() == 0) {
//                 while (ValueObject.list.size() == 0) {
                        System.out.println("wait begin ThreadName="
                                  + Thread.currentThread().getName());
                        lock.wait();
                        System.out.println("wait   end ThreadName="
                                  + Thread.currentThread().getName());
                   }
                   ValueObject.list.remove(0);
                   System.out.println("list size=" + ValueObject.list.size());
              }
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }

}
public class ValueObject {
     public static List list = new ArrayList();

}
public class ThreadAdd extends Thread {
     private Add p;
     public ThreadAdd(Add p) {
          super();
          this.p = p;
     }
     @Override
     public void run() {
          p.add();
     }

}
public class ThreadSubtract extends Thread {
     private Subtract r;
     public ThreadSubtract(Subtract r) {
          super();
          this.r = r;
     }
     @Override
     public void run() {
          r.subtract();
     }

}
public class Run {
     public static void main(String[] args) throws InterruptedException {
          String lock = new String("");
          Add add = new Add(lock);
          Subtract subtract = new Subtract(lock);
          ThreadSubtract subtract1Thread = new ThreadSubtract(subtract);
          subtract1Thread.setName("subtract1Thread");
          subtract1Thread.start();
          ThreadSubtract subtract2Thread = new ThreadSubtract(subtract);
          subtract2Thread.setName("subtract2Thread");
          subtract2Thread.start();
          Thread.sleep(1000);
          ThreadAdd addThread = new ThreadAdd(add);
          addThread.setName("addThread");
          addThread.start();
     }

}
在if (ValueObject.list.size() == 0)情况下，输出结果：
wait begin ThreadName=subtract1Thread
wait begin ThreadName=subtract2Thread
wait   end ThreadName=subtract2Thread
list size=0
wait   end ThreadName=subtract1Thread
Exception in thread "subtract1Thread" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
     at java.util.ArrayList.rangeCheck(Unknown Source)
     at java.util.ArrayList.remove(Unknown Source)
     at entity.Subtract.subtract(Subtract.java:24)
     at extthread.ThreadSubtract.run(ThreadSubtract.java:16)
更换为while(ValueObject.list.size() == 0)情况下，输出结果：
wait begin ThreadName=subtract2Thread
wait begin ThreadName=subtract1Thread
wait   end ThreadName=subtract1Thread
list size=0
wait   end ThreadName=subtract2Thread
wait begin ThreadName=subtract2Thread

出现异常的原因：实现了两次删除remove（）操作，第一次能正常删除，第二次则报异常
用while（…）替换掉if（…），当线程被通知（notify）后，会再进一次进行判断长度是非为0。

生产者/消费者模式实现

一生产与一消费：操作值

生产者：

package entity;
//生产者
public class P {
     private String lock;
     public P(String lock) {
          super();
          this.lock = lock;
     }
     public void setValue() {
          try {
              synchronized (lock) {
                   if (!ValueObject.value.equals("")) {
                        lock.wait();
                   }
                   String value = System.currentTimeMillis() + "_"
                             + System.nanoTime();
                   System.out.println("set的值是" + value);
                   ValueObject.value = value;
                   lock.notify();
              }
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }
}

消费者：

package entity;
//消费者
public class C {
     private String lock;
     public C(String lock) {
          super();
          this.lock = lock;
     }
     public void getValue() {
          try {
              synchronized (lock) {
                   if (ValueObject.value.equals("")) {
                        lock.wait();
                   }
                   System.out.println("get的值是" + ValueObject.value);
                   ValueObject.value = "";
                   lock.notify();
              }
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }
}

存储值的对象：

package entity;
public class ValueObject {
     public static String value = "";

生产者线程：

package extthread;
import entity.P;
public class ThreadP extends Thread {
     private P p;
     public ThreadP(P p) {
          super();
          this.p = p;
     }
     @Override
     public void run() {
          while (true) {
              p.setValue();
          }
     }
}

消费者线程：

package extthread;
import entity.C;
public class ThreadC extends Thread {
     private C r;
     public ThreadC(C r) {
          super();
          this.r = r;
     }
     @Override
     public void run() {
          while (true) {
              r.getValue();
          }
     }
}

运行类：

package test;
import entity.P;
import entity.C;
import extthread.ThreadP;
import extthread.ThreadC;
public class Run {
    public static void main(String[] args) {
        String lock = new String("");
        P p = new P(lock);
        C r = new C(lock);
        ThreadP pThread = new ThreadP(p);
        ThreadC rThread = new ThreadC(r);
        pThread.start();
        rThread.start();
    }
}
输出结果：
set的值是1511090029379_209828520790577
get的值是1511090029379_209828520790577
set的值是1511090029379_209828520806165
get的值是1511090029379_209828520806165
set的值是1511090029379_209828520837751
get的值是1511090029379_209828520837751
set的值是1511090029379_209828520848006
get的值是1511090029379_209828520848006
set的值是1511090029379_209828520858262
get的值是1511090029379_209828520858262
set的值是1511090029379_209828520868517
get的值是1511090029379_209828520868517
set的值是1511090029379_209828520885336
get的值是1511090029379_209828520885336

多生产与多消费：操作值-假死
在未将notify（）更换为notifyAll（）之前,容易造成假死现象。
“假死”现象其实就是线程进入waiting等待状态。如果全部的线程都进入waiting状态，则呈现就不再执行任何业务功能了，整个项目呈停止状态。

假死出现的主要原因是有可能连续唤醒同类，导致所有线程呈waiting状态。

在将notify更换为notifyAll（）以后，解除假死现象。
需要注意的是，在多生产与多消费中，一定要将if (ValueObject.value.equals(“”)) 更换为while（….），理由同上一节。

通过管道进行线程间通信：字节流/字符流

管道流是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读数据。
通过使用管道，实现不同线程间的通信，而无需借助类似于临时文件类的东西
1.PipedInputStream和PipedOutputStream
2.PipedReader和PipedWriter

public class ThreadRead extends Thread {
     private ReadData read;
     private PipedInputStream input;
     public ThreadRead(ReadData read, PipedInputStream input) {
          super();
          this.read = read;
          this.input = input;
     }
     @Override
     public void run() {
          read.readMethod(input);
     }
}
package extthread;
import java.io.PipedOutputStream;
import service.WriteData;
public class ThreadWrite extends Thread {
    private WriteData write;
    private PipedOutputStream out;
    public ThreadWrite(WriteData write, PipedOutputStream out) {
        super();
        this.write = write;
        this.out = out;
    }
    @Override
    public void run() {
        write.writeMethod(out);
    }
}
package service;
import java.io.IOException;
import java.io.PipedInputStream;
public class ReadData {
    public void readMethod(PipedInputStream input) {
        try {
            System.out.println("read  :");
            byte[] byteArray = new byte[20];
            int readLength = input.read(byteArray);
            while (readLength != -1) {
                String newData = new String(byteArray, 0, readLength);
                System.out.print(newData);
                readLength = input.read(byteArray);
            }
            System.out.println();
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package service;
import java.io.IOException;
import java.io.PipedOutputStream;
public class WriteData {
    public void writeMethod(PipedOutputStream out) {
        try {
            System.out.println("write :");
            for (int i = 0; i < 300; i++) {
                String outData = "" + (i + 1);
                out.write(outData.getBytes());
                System.out.print(outData);
            }
            System.out.println();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package test;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import service.ReadData;
import service.WriteData;
import extthread.ThreadRead;
import extthread.ThreadWrite;
public class Run {
    public static void main(String[] args) {
        try {
            WriteData writeData = new WriteData();
            ReadData readData = new ReadData();
            PipedInputStream inputStream = new PipedInputStream();
            PipedOutputStream outputStream = new PipedOutputStream();
            // inputStream.connect(outputStream);
            outputStream.connect(inputStream);
            ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
            threadWrite.start();

            Thread.sleep(2000);
            ThreadRead threadRead = new ThreadRead(readData, inputStream);
            threadRead.start();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


输出结果：
write :
1234567891011121314151 ......
read  :
1234567891011121314151........

通过 // inputStream.connect(outputStream);// outputStream.connect(inputStream); 使两个Stream之间产生通信链接，这样才可以将数据进行输出与输入。

通过管道进行线程间通信：字符流

    public void readMethod(PipedReader input) {
          try {
              System.out.println("read  :");
              char[] byteArray = new char[20];
              int readLength = input.read(byteArray);
              while (readLength != -1) {
                   String newData = new String(byteArray, 0, readLength);
                   System.out.print(newData);
                   readLength = input.read(byteArray);
              }
              System.out.println();
              input.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
     }
.........
大部分与字节流类似

实战：等待/通知之交叉备份

（最近也在琢磨做一个真正能派上用场的多线程备份数据库的小项目，后期完成了会在这里贴一个后续链接，先占个位吧~ 哈哈哈哈哈， 2017年11月19日留）
目标：创建20个线程，其中10个线程是将数据备份到数据库A，另外10个线程将数据备份到数据库B中去，并且备份数据库A和备份数据库B是交叉进行的。

DBTools：

package service;
public class DBTools {
     volatile private boolean prevIsA = false;
     synchronized public void backupA() {
          try {
              while (prevIsA == true) {
                   wait();
              }
              for (int i = 0; i < 5; i++) {
                   System.out.println("★★★★★");
              }
              prevIsA = true;
              notifyAll();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }
     synchronized public void backupB() {
          try {
              while (prevIsA == false) {
                   wait();
              }
              for (int i = 0; i < 5; i++) {
                   System.out.println("☆☆☆☆☆");
              }
              prevIsA = false;
              notifyAll();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }

BackupA/BackupB：

package extthread;
import service.DBTools;
public class BackupA extends Thread {
     private DBTools dbtools;
     public BackupA(DBTools dbtools) {
          super();
          this.dbtools = dbtools;
     }
     @Override
     public void run() {
          dbtools.backupA();
     }
}
package extthread;
import service.DBTools;
public class BackupB extends Thread {
     private DBTools dbtools;
     public BackupB(DBTools dbtools) {
          super();
          this.dbtools = dbtools;
     }
     @Override
     public void run() {
          dbtools.backupB();
     }

}

Run：

package test.run;
import service.DBTools;
import extthread.BackupA;
import extthread.BackupB;
public class Run {
    public static void main(String[] args) {
        DBTools dbtools = new DBTools();
        for (int i = 0; i < 20; i++) {
            BackupB output = new BackupB(dbtools);
            output.start();
            BackupA input = new BackupA(dbtools);
            input.start();
        }
    }
}
结果：
★★★★★
★★★★★
★★★★★
★★★★★
★★★★★
☆☆☆☆☆
☆☆☆☆☆
☆☆☆☆☆
☆☆☆☆☆
☆☆☆☆☆
★★★★★
★★★★★
★★★★★
★★★★★
★★★★★
.........

交替打印的原理就是：volatile private boolean prevIsA=false;

方法join的使用

join（）：等待线程对象销毁。

用join（）方法来解决

package extthread;
public class MyThread extends Thread {
     @Override
     public void run() {
          try {
              int secondValue = (int) (Math.random() * 10000);
              System.out.println(secondValue);
              Thread.sleep(secondValue);
          } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
          }
     }
}

package test;
import extthread.MyThread;
public class Test {
     public static void main(String[] args) {
          try {
              MyThread threadTest = new MyThread();
              threadTest.start();
              threadTest.join();
              System.out.println("我想当threadTest对象执行完毕后我再执行，我做到了");
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }

}
输出结果：
9715
我想当threadTest对象执行完毕后我再执行，我做到了

join 方法具有使线程排队运行的作用，有些类似同步的运行效果。join 与 synchronized 的区别是：join 在内部使用 wait() 方法进行等待，而 synchronized 关键字使用的是 “对象监视器” 原理做为同步。

方法join与异常

在join过程中，如果当前线程对象被中断（interrupt），则当前线程出现异常（InterruptedException）。

方法join（long）的使用

方法join（long）中的参数是设定是等待的时间

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

只等待XXXX毫秒时间

方法join（long）与sleep（long）的区别

方法join（long）的功能是使用wait（long）方法来实现的，所以join（long）方法具有释放锁的特点
而Thread.sleep(long)方法却不释放锁！

类ThreadLocal的使用

通过类ThreadLocal实现每一个线程都有自己的共享变量，解决的就是每个线程绑定自己的值。

线程变量的隔离性

package extthread;
import tools.Tools;
public class ThreadA extends Thread {
     @Override
     public void run() {
          try {
              for (int i = 0; i < 100; i++) {
                   if (Tools.tl.get() == null) {
                        Tools.tl.set("ThreadA" + (i + 1));
                   } else {
                        System.out.println("ThreadA get Value=" + Tools.tl.get());
                   }
                   Thread.sleep(200);
              }
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }
}
package extthread;
import tools.Tools;
public class ThreadB extends Thread {
     @Override
     public void run() {
          try {
              for (int i = 0; i < 100; i++) {
                   if (Tools.tl.get() == null) {
                        Tools.tl.set("ThreadB" + (i + 1));
                   } else {
                        System.out.println("ThreadB get Value=" + Tools.tl.get());
                   }
                   Thread.sleep(200);
              }
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
     }

}
package tools;
public class Tools {
     public static ThreadLocal tl = new ThreadLocal();

}
package test;
import tools.Tools;
import extthread.ThreadA;
import extthread.ThreadB;
public class Run {
    public static void main(String[] args) {
        try {
            ThreadA a = new ThreadA();
            ThreadB b = new ThreadB();
            a.start();
            b.start();
            for (int i = 0; i < 100; i++) {
                if (Tools.tl.get() == null) {
                    Tools.tl.set("Main" + (i + 1));
                } else {
                    System.out.println("Main get Value=" + Tools.tl.get());
                }
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
输出结果：
ThreadB get Value=ThreadB1
Main get Value=Main1
ThreadA get Value=ThreadA1
ThreadB get Value=ThreadB1
Main get Value=Main1
ThreadA get Value=ThreadA1
Main get Value=Main1
ThreadB get Value=ThreadB1
ThreadA get Value=ThreadA1
Main get Value=Main1
...........

解决get（）返回null问题

通过继承ThreadLocal类，重写 initialValue方法

package ext;
public class ThreadLocalExt extends ThreadLocal {
     @Override
     protected Object initialValue() {
          return "我是默认值 第一次get不再为null";
     }
}

实现首次get（）不为null；

InheritableThreadLocal 类的使用

该类扩展了 ThreadLocal，为子线程提供从父线程那里继承的值：在创建子线程时，子线程会接收所有可继承的线程局部变量的初始值，以获得父线程所具有的值。
通常，子线程的值与父线程的值是一致的；但是，通过重写这个类中的 childValue 方法，子线程的值可以作为父线程值的一个任意函数（parentValue+“XXXX”）。

D.Chuan

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Java多线程编程核心技术】3.线程间通信 -笔记总结

相关链接：【Java多线程编程核心技术】1.Java多线程技能-笔记总结【Java多线程编程核心技术】2.对象及变量的并发访问（上）-笔记总结【Java多线程编程核心技术】2.对象及变量的并发访问（下）-笔记总结【Java多线程编程核心技术】3.线程间通信 -笔记总结【Java多线程编程核心技术】4.Lock的使用-笔记总结【Java多线程编程核心技术】5.定时器Timer...
复制链接

扫一扫