资讯安全论坛下载读书程序开发数据库系统网络电子书微信学院站长学院 QQ 考试

频道栏目

SQL Server| MySQL| Oracle| DB2| Sybase| 其他综合| SQL教程|

首页 > 程序开发 > 软件开发 > Java > 正文

java线程之间的通信方式实例讲解

2020-09-28 14:46:21 来源：nwpu_geeker的博客

收藏我要投稿

引言

当多个线程需要协作来完成一件事情的时候，如何去等待其他线程执行，又如何当线程执行完去通知其他线程结束等待。

线程与进程的区别

进程可以独立运行，它是系统进行资源分配和调度的独立单位。

线程是进程的一个实体，是CPU调度和分派的基本单位，比进程更小的独立单位，它基本上不拥有系统资源。

他们之间的联系：

一个线程属于一个进程，而一个进程有多个线程，多个线程共享该进程的所有资源。

区别：

1.调度：线程作为CPU调度和分派的基本单位，进程拥有系统资源的独立单位。

2.并发性：进程之间并发运行，同一个进程的多个线程也能并发执行。

3.拥有资源，进程是拥有系统资源的基本单位，线程不拥有资源，但能访问进程的资源。

线程之间的通信方式有哪些

1.join

2.共享变量(volatile、AtomicInteger)

3.notify/wait

4.lock/condition

5.管道

join

首先，开启两个线程，分别打印123，线程A和线程B会不按套路打印。

如果必须要线程A在线程B之前打印123呢？

需要使用thread1.join();//我会等待线程1执行完成后再进行执行

join的原理

实际上join方法内部是通过wait实现的。

上一段jdk源码

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;
}
  }
 }

这个join的原理很简单，前面那些if条件不管，主要看while循环里面的，while循环就是不断去判断this.isAlive的结果，用上面的例子，这个this就是joinThread。然后关键的代码就是wait(delay);一个定时的wait。这个wait的对象也是this,就是joinThread。上面我们已经讲了wait一定要在同步方法或者同步代码块中，源码中join方法的修饰符就是一个synchronized，表明这是一个同步的方法。

不要看调用wait是joinThread，是一个线程。但是真正因为wait进入阻塞状态的，是持有对象监视器的线程，这里的对象监视器是joinThread,持有他的是main线程，因为在main线程中执行了join这个同步方法。

所以main线程不断的wait，直到调用join方法那个线程对象销毁，才继续向下执行。

但是源码中只有wait的方法，没有notify的方法。因为notify这个操作是JVM通过检测线程对象销毁而调用的native方法，是C++实现的，在源码中是找不到对应这个wait方法而存在的notify方法的。

也就是说。

利用Thread.join()方法来实现，join()方法的作用是等待调用线程执行完之后再执行任务。

这个是必须线程A全部执行完，再去执行B.

wait/notify

如果是交替打印呢？

必须使用wait()和notify()方法。

一道面试题。

编写两个线程，一个线程打印1~52，另一个线程打印字母A~Z，打印顺序为12A34B56C……5152Z，要求使用线程间的通信。

代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by Edison Xu on 2020/09/28.
 */
public enum Helper {

 instance;

 private static final ExecutorService tPool = Executors.newFixedThreadPool(2);

 public static String[] buildNoArr(int max) {
  String[] noArr = new String[max];
  for(int i=0;i使用wait和notify
public class MethodOne {
 private final ThreadToGo threadToGo = new ThreadToGo();
 public Runnable newThreadOne() {
  final String[] inputArr = Helper.buildNoArr(52);
  return new Runnable() {
private String[] arr = inputArr;
public void run() {
 try {
  for (int i = 0; i < arr.length; i=i+2) {
synchronized (threadToGo) {
 while (threadToGo.value == 2)
  threadToGo.wait();
 Helper.print(arr[i], arr[i + 1]);
 threadToGo.value = 2;
 threadToGo.notify();
}
  }
 } catch (InterruptedException e) {
  System.out.println("Oops...");
 }
}
  };
 }
 public Runnable newThreadTwo() {
  final String[] inputArr = Helper.buildCharArr(26);
  return new Runnable() {
private String[] arr = inputArr;
public void run() {
 try {
  for (int i = 0; i < arr.length; i++) {
synchronized (threadToGo) {
 while (threadToGo.value == 1)
  threadToGo.wait();
 Helper.print(arr[i]);
 threadToGo.value = 1;
 threadToGo.notify();
}
  }
 } catch (InterruptedException e) {
  System.out.println("Oops...");
 }
}
  };
 }
 class ThreadToGo {
  int value = 1;
 }
 public static void main(String args[]) throws InterruptedException {
  MethodOne one = new MethodOne();
  Helper.instance.run(one.newThreadOne());
  Helper.instance.run(one.newThreadTwo());
  Helper.instance.shutdown();
 }
}

注意：
wait和notify方法必须放在同步块里面，因为要对应同一个对象监视器。而sleep没有
原理详解：
wait方法会使执行该wait方法的线程停止，直到等到了notify的通知。细说一下，执行了wait方法的那个线程会因为wait方法而进入等待状态，该线程也会进入阻塞队列中。而执行了notify那个线程在执行完同步代码之后会通知在阻塞队列中的线程，使其进入就绪状态。被重新唤醒的线程会试图重新获得临界区的控制权，也就是对象锁，然后继续执行临界区也就是同步语句块中wait之后的代码。
上面这个描述，可以看出一些细节。
1.wait方法进入了阻塞队列，而上文讲过执行notify操作的线程与执行wait的线程是拥有同一个对象监视器，也就说wait方法执行之后，立刻释放掉锁，这样，另一个线程才能执行同步代码块，才能执行notify。
2.notify线程会在执行完同步代码之后通知在阻塞队列中的线程，也就是说notify的那个线程并不是立即释放锁，而是在同步方法执行完，释放锁以后，wait方法的那个线程才会继续执行。
3.被重新唤醒的线程会试图重新获得锁，也就说，在notify方法的线程释放掉锁以后，其通知的线程是不确定的，看具体是哪一个阻塞队列中的线程获取到对象锁。
这里详细说一下，这个结果。wait使线程进入了阻塞状态，阻塞状态可以细分为3种：
● 等待阻塞：运行的线程执行wait方法，JVM会把该线程放入等待队列中。
● 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池当中。
● 其他阻塞： 运行的线程执行了Thread.sleep或者join方法，或者发出I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止，或者超时、或者I/O处理完毕时，线程重新转入可运行状态。
可运行状态就是线程执行start时，就是可运行状态，一旦CPU切换到这个线程就开始执行里面的run方法就进入了运行状态。
上面会出现这个结果，就是因为notify仅仅让一个线程进入了可运行状态，而另一个线程则还在阻塞中。而notifyAll则使所有的线程都从等待队列中出来，而因为同步代码的关系，获得锁的线程进入可运行态，没有得到锁的则进入锁池，也是阻塞状态，但是会因为锁的释放而重新进入可运行态。所以notifyAll会让所有wait的线程都会继续执行。
Lock和Condition
如何程序不使用synchronized关键字来保持同步，而是直接适用Lock对像来保持同步，则系统中不存在隐式的同步监视器对象，也就不能使用wait()、notify()、notifyAll()来协调线程的运行.
当使用LOCK对象保持同步时，JAVA为我们提供了Condition类来协调线程的运行。关于Condition类，JDK文档里进行了详细的解释.，再次就不啰嗦了。
代码如下：
public class MethodTwo {
 private Lock lock = new ReentrantLock(true);
 private Condition condition = lock.newCondition();
 private final ThreadToGo threadToGo = new ThreadToGo();
 public Runnable newThreadOne() {
  final String[] inputArr = Helper.buildNoArr(52);
  return new Runnable() {
private String[] arr = inputArr;
public void run() {
 for (int i = 0; i < arr.length; i=i+2) {
  try {
lock.lock();
while(threadToGo.value == 2)
 condition.await();
Helper.print(arr[i], arr[i + 1]);
threadToGo.value = 2;
condition.signal();
  } catch (InterruptedException e) {
e.printStackTrace();
  } finally {
lock.unlock();
  }
 }
}
  };
 }
 public Runnable newThreadTwo() {
  final String[] inputArr = Helper.buildCharArr(26);
  return new Runnable() {
private String[] arr = inputArr;
public void run() {
 for (int i = 0; i < arr.length; i++) {
  try {
lock.lock();
while(threadToGo.value == 1)
 condition.await();
Helper.print(arr[i]);
threadToGo.value = 1;
condition.signal();
  } catch (Exception e) {
e.printStackTrace();
  } finally {
lock.unlock();
  }
 }
}
  };
 }
 class ThreadToGo {
  int value = 1;
 }
 public static void main(String args[]) throws InterruptedException {
  MethodTwo two = new MethodTwo();
  Helper.instance.run(two.newThreadOne());
  Helper.instance.run(two.newThreadTwo());
  Helper.instance.shutdown();
 }
}

输出结果和上面是一样的！ 只不过这里 显示的使用Lock对像来充当同步监视器,使用Condition对象来暂停指定线程，唤醒指定线程！
共享变量(volatile、AtomicInteger)
volatile修饰的变量值直接存在main memory里面，子线程对该变量的读写直接写入main memory，而不是像其它变量一样在local thread里面产生一份copy。volatile能保证所修饰的变量对于多个线程可见性，即只要被修改，其它线程读到的一定是最新的值。
代码如下：
public class MethodThree {
 private volatile ThreadToGo threadToGo = new ThreadToGo();
 class ThreadToGo {
  int value = 1;
 }
 public Runnable newThreadOne() {
  final String[] inputArr = Helper.buildNoArr(52);
  return new Runnable() {
private String[] arr = inputArr;
public void run() {
 for (int i = 0; i < arr.length; i=i+2) {
  while(threadToGo.value==2){}
  Helper.print(arr[i], arr[i + 1]);
  threadToGo.value=2;
 }
}
  };
 }
 public Runnable newThreadTwo() {
  final String[] inputArr = Helper.buildCharArr(26);
  return new Runnable() {
private String[] arr = inputArr;
public void run() {
 for (int i = 0; i < arr.length; i++) {
  while(threadToGo.value==1){}
  Helper.print(arr[i]);
  threadToGo.value=1;
 }
}
  };
 }
 public static void main(String args[]) throws InterruptedException {
  MethodThree three = new MethodThree();
  Helper.instance.run(three.newThreadOne());
  Helper.instance.run(three.newThreadTwo());
  Helper.instance.shutdown();
 }
}

管道
管道流是JAVA中线程通讯的常用方式之一，基本流程如下：
1）创建管道输出流PipedOutputStream pos和管道输入流PipedInputStream pis
2）将pos和pis匹配，pos.connect(pis);
3）将pos赋给信息输入线程，pis赋给信息获取线程，就可以实现线程间的通讯了
代码如下：
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class testPipeConnection {

 public static void main(String[] args) {
  /**
* 创建管道输出流
*/
  PipedOutputStream pos = new PipedOutputStream();
  /**
* 创建管道输入流
*/
  PipedInputStream pis = new PipedInputStream();
  try {
/**
 * 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现
 */
pos.connect(pis);
  } catch (IOException e) {
e.printStackTrace();
  }
  /**
* 创建生产者线程
*/
  Producer p = new Producer(pos);
  /**
* 创建消费者线程
*/
  Consumer1 c1 = new Consumer1(pis);
  /**
* 启动线程
*/
  p.start();
  c1.start();
 }
}

/**
 * 生产者线程(与一个管道输入流相关联)
 * 
 */
class Producer extends Thread {
 private PipedOutputStream pos;

 public Producer(PipedOutputStream pos) {
  this.pos = pos;
 }

 public void run() {
  int i = 0;
  try {
while(true)
{
this.sleep(3000);
pos.write(i);
i++;
}
  } catch (Exception e) {
e.printStackTrace();
  }
 }
}

/**
 * 消费者线程(与一个管道输入流相关联)
 * 
 */
class Consumer1 extends Thread {
 private PipedInputStream pis;

 public Consumer1(PipedInputStream pis) {
  this.pis = pis;
 }

 public void run() {
  try {
while(true)
{
System.out.println("consumer1:"+pis.read());
}
  } catch (IOException e) {
e.printStackTrace();
  }
 }
}

程序启动后，就可以看到producer线程往consumer1线程发送数据。
consumer1:0
consumer1:1
consumer1:2
consumer1:3
......

管道流虽然使用起来方便，但是也有一些缺点
1）管道流只能在两个线程之间传递数据
线程consumer1和consumer2同时从pis中read数据，当线程producer往管道流中写入一段数据后，每一个时刻只有一个线程能获取到数据，并不是两个线程都能获取到producer发送来的数据，因此一个管道流只能用于两个线程间的通讯。不仅仅是管道流，其他IO方式都是一对一传输。
2）管道流只能实现单向发送，如果要两个线程之间互通讯，则需要两个管道流
可以看到上面的例子中，线程producer通过管道流向线程consumer发送数据，如果线程consumer想给线程producer发送数据，则需要新建另一个管道流pos1和pis1，将pos1赋给consumer1，将pis1赋给producer，具体例子本文不再多说。

点击复制链接与好友分享!回本站首页

相关TAG标签线程 java 通信方式进程

上一篇：java排序算法学习之冒泡，选择排序，二分查找，工具类等实现讲解

下一篇：java线程方法之join简单总结（代码实例）

相关文章

热门专题推荐 python div+css css教程 html5 html教程 jquery Android SDK php mysql oracle

图文推荐

文章

推荐

· oracle like�：檠�

· Oracle诊断案例---如何诊断和解决CPU高

· Ubuntu定时备份oracle数据库实现

· oracle job中时间间隔设置

· oracle树状数据结构查询结果特殊展示

· oracle返回多结果集

· oracle 10g已删除数据查询的两种方式

· undo系列学习之undo段及区的状态和使用

· win7激活工具

· win10激活工具

· win7激活工具旗舰版

· office2010激活密钥

· windows7激活密钥

· office2010激活工具

· 小马激活工具

· win10激活工具

点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 全峰安全联盟--致力于做实用的IT技术学习网站