CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章如何在Java中创建线程通信的四种方式你知道吗由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1.1 创建线程

1.1.1 创建线程的四种方式

【1】继承Thread类 。

【2】实现Runnable接口 。

【3】实现Callable，获取返回值 。

【4】实现FutureTask类 。

Thread类是一个Runnable接口的实现类，Thread类中通过调用私有的init来实现初始化.

g：线程组 。

target：实现Runnable接口的线程处理类 。

name：线程名称，如果没有指定则默认Thread-随机数 。

stackSize：线程初始栈大小 。

1.1.2 Thread类与Runnable接口的比较

1：由于Java“单继承，多实现”的特性，Runnable接口使用起来比Thread更灵活.

2：Runnable接口出现更符合面向对象，将线程单独进行对象的封装.

3：Runnable接口出现，降低了线程对象和线程任务的耦合性.

4：如果使用线程时不需要使用Thread类的诸多方法，显然使用Runnable接口更为轻量。Thread是扩展了Runnable接口的对象.

1.1.3 Callable、Future与FutureTask

使用Runnable和Thread来创建一个新的线程。但是它们有一个弊端，就是run方法是没有返回值的。而有时候我们希望开启一个线程去执行一个任务，并且这个任务执行完成后有一个返回值.

@FunctionalInterfacepublic interface Callable<V> {  /**   * 处理任务并返回一个结果   *   * @return computed result   * @throws Exception if unable to compute a result   */  V call() throws Exception;}

Callable一般是配合线程池工具ExecutorService来使用的。ExecutorService可以使用submit方法来让一个Callable接口执行。它会返回一个Future，我们通过 。

Future.get()就可以获取线程执行的返回结果了.

  。

1.2 线程组和线程优先级

Java中用ThreadGroup来表示线程组，我们可以使用线程组对线程进行批量控制.

ThreadGroup和Thread的关系就如同他们的字面意思一样简单粗暴，每个Thread必然存在于一个ThreadGroup中，Thread不能独立于ThreadGroup存在。执行main()方法线程的名字是main，如果在new Thread时没有显式指定，那么默认将父线程（当前执行new Thread的线程）线程组设置为自己的线程组.

ThreadGroup管理着它下面的Thread，ThreadGroup是一个标准的向下引用的树状结构，这样设计的原因是防止”上级”线程被”下级”线程引用而无法有效地被GC回收.

Java中线程优先级可以指定，范围是1~10。但是并不是所有的操作系统都支持10级优先级的划分（比如有些操作系统只支持3级划分：低，中，高），Java只是给操作系统一个优先级的参考值，线程最终在操作系统的优先级是多少还是由操作系统决定.

Java默认的线程优先级为5，线程的执行顺序由调度程序来决定，线程的优先级会在线程被调用之前设定.

通常情况下，高优先级的线程将会比低优先级的线程有更高的几率得到执行。我们使用方法Thread类的setPriority()实例方法来设定线程的优先级.

Java中的优先级来说不是特别的可靠，Java程序中对线程所设置的优先级只是给操作系统一个建议，操作系统不一定会采纳。而真正的调用顺序，是由操作系统的线程调度算法决定的.

Java提供一个线程调度器来监视和控制处于RUNNABLE状态的线程。线程的调度策略采用抢占式，优先级高的线程比优先级低的线程会有更大的几率优先执行。在优先级相同的情况下，按照“先到先得”的原则。每个Java程序都有一个默认的主线程，就是通过JVM启动的第一个线程main线程.

还有一种线程称为守护线程（Daemon），守护线程默认的优先级比较低.

如果某线程是守护线程，那如果所有的非守护线程结束，这个守护线程也会自动结束.

应用场景是：当所有非守护线程结束时，结束其余的子线程（守护线程）自动关闭，就免去了还要继续关闭子线程的麻烦.

一个线程默认是非守护线程，可以通过Thread类的setDaemon(boolean on)来设置.

【一个线程必然存在于一个线程组中，那么当线程和线程组的优先级不一致的时候将会怎样呢？】 。

public static void main(String[] args) {  ThreadGroup threadGroup = new ThreadGroup("t1");  threadGroup.setMaxPriority(6);  Thread thread = new Thread(threadGroup,"thread");  thread.setPriority(9);  System.out.println("我是线程组的优先级"+threadGroup.getMaxPriority());  System.out.println("我是线程的优先级"+thread.getPriority());}

所以，如果某个线程优先级大于线程所在线程组的最大优先级，那么该线程的优先级将会失效，取而代之的是线程组的最大优先级.

  。

1.3 Java线程的状态及主要转化方法

Enum Thread.State 。

【1】反复调用同一个线程的start()方法是否可行?

【2】假如一个线程执行完毕（此时处于TERMINATED状态），再次调用这个线程的start()方法是否可行?

查看Thread类中start()方法源码，代码如下 。

public synchronized void start() {		//threadStatus表示处于NEW状态的线程      if (threadStatus != 0)          throw new IllegalThreadStateException();		 //通知当前线程的线程组这个线程将要启动，并添加当前线程到线程组中		 //当前线程组未启动线程数减少      group.add(this);      boolean started = false;      try {          start0();          started = true;      } finally {          try {				//处理启动失败的线程              if (!started) {                  group.threadStartFailed(this);              }          } catch (Throwable ignore) {          }      }  }  //本地方法执行线程的实际启动流程  private native void start0();

在start()内部，这里有一个threadStatus的变量。如果它不等于0，调用start()是会直接抛出异常的.

我是在start()方法内部的最开始打的断点，叙述下在我这里打断点看到的结果:

测试代码如下 。

@Test  public  void testThreadState(){      Thread thread = new Thread(()->{          System.out.println("Thread Run...");      });      thread.start();      thread.start();  }

第一个 thread.start();执行情况如下 。

第二个 thread.start();执行情况如下 。

两个问题的答案都是不可行，在调用一次start()之后，threadStatus的值会改变（threadStatus !=0），此时再次调用start()方法会抛出IllegalThreadStateException异常.

比如，threadStatus为2代表当前线程状态为TERMINATED.

  。

1.4 Java线程间的通信

线程同步是线程之间按照一定的顺序执行.

1.4.1 等待/通知机制

Java多线程的等待/通知机制是基于Object类的wait()方法和notify(), notifyAll()方法来实现的.

notify()方法会随机叫醒一个正在等待的线程，而notifyAll()会叫醒所有正在等待的线程.

1.4.2 信号量

JDK提供了一个类似于“信号量”功能的类Semaphore。但本文不是要介绍这个类，而是介绍一种基于volatile关键字的自己实现的信号量通信.

volitile关键字能够保证内存的可见性，如果用volitile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的.

【需求】让线程1输出0，然后线程2输出1，再然后线程A输出2…以此类推。我应该怎样实现呢?

private static Object lock=new Object();  private static volatile  int sign=0;  static class MyThread1 implements  Runnable{      @SneakyThrows      @Override      public void run() {          while (sign<5){              if (sign%2==0){                  System.out.println("线程1--->"+sign);                  synchronized (lock){                      sign++;                  }              }          }      }  }  static class MyThread2 implements  Runnable{      @Override      public void run() {          while (sign<5){              if (sign%2!=0){                  System.out.println("线程2--->"+sign);                  synchronized (lock){                      sign++;                  }              }          }      }  }  public static void main(String[] args) throws InterruptedException {      Thread threadA = new Thread(new MyThread1());      Thread threadB = new Thread(new MyThread2());      threadA.start();      threadB.start();      Thread.sleep(4000);  }

注意:

上面使用了一个volatile变量signal来实现了“信号量”的模型。但是volatile仅仅只线程可见的，signal++并不是一个原子操作，所以我们需要使用synchronized给它“上锁” 。

1.4.3 管道

管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream。其中，前面两个是基于字符的，后面两个是基于字节流的.

public class PipeExample {  /**   * 构建一个管道读的线程   */  static class ReaderThread implements  Runnable{      private  PipedReader pipedReader;      public ReaderThread(PipedReader pipedReader) {          this.pipedReader = pipedReader;      }      @Override      public void run() {          int count=0;          try          {//接收并输出流              while ((count= pipedReader.read())!=-1){                  System.out.println((char)count);              }          } catch (IOException e) {              e.printStackTrace();          }      }  }  /**   * 构建一个写入管道流的线程   */  static class WriterThread implements Runnable {      private PipedWriter writer;      public WriterThread(PipedWriter writer) {          this.writer = writer;      }      @SneakyThrows      @Override      public void run() {          try {              writer.write("qwertyui");          } catch (IOException e) {              e.printStackTrace();          }finally {              //写入管道的流必须关闭              writer.close();          }      }  }  public static void main(String[] args) throws IOException, InterruptedException {      PipedWriter writer = new PipedWriter();      PipedReader reader = new PipedReader();      // 这里注意一定要连接，才能通信      writer.connect(reader);      new Thread(new ReaderThread(reader)).start();      Thread.sleep(1000);      new Thread(new WriterThread(writer)).start();  }}

我们通过线程的构造函数，传入了PipedWrite和PipedReader对象。可以简单分析一下这个示例代码的执行流程:

1：线程ReaderThread开始执行 。

2：线程ReaderThread使用管道reader.read()进入”阻塞“ 。

3：线程WriterThread开始执行 。

4：线程WriterThread用writer.write(“XXXX”)往管道写入字符串 。

5：线程WriterThread使用writer.close()结束管道写入，并执行完毕 。

6：线程ReaderThread接受到管道输出的字符串并打印 。

7：线程ReaderThread执行完毕 。

管道通信的应用场景：使用管道多半与I/O流相关。当我们一个线程需要先另一个线程发送一个信息（比如字符串）或者文件等等时，就需要使用管道通信了.

  。

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我的更多内容！ 。

原文链接：https://blog.csdn.net/Octopus21/article/details/120106529 。

最后此篇关于如何在Java中创建线程通信的四种方式你知道吗的文章就讲到这里了,如果你想了解更多关于如何在Java中创建线程通信的四种方式你知道吗的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。