Java多线程连续打印abc实现方法详解

一道编程题如下:

实例化三个线程,一个线程打印a,一个线程打印b,一个线程打印c,三个线程同时执行,要求打印出10个连着的abc。

题目分析:

通过题意我们可以得出,本题需要我们使用三个线程,三个线程分别会打印6次字符,关键是如何保证顺序一定是abc...呢。所以此题需要同步机制来解决问题!

令打印字符A的线程为ThreadA,打印B的ThreadB,打印C的为ThreadC。问题为三线程间的同步唤醒操作,主要的目的就是使程序按ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程,因此本人整理出了三种方式来解决此问题。

一、通过两个锁(不推荐,可读性和安全性比较差)

package com.demo.test;

/**
 * 基于两个lock实现连续打印abcabc....
 * @author lixiaoxi
 *
 */
public class TwoLockPrinter implements Runnable {

  // 打印次数
  private static final int PRINT_COUNT = 10;
  // 前一个线程的打印锁
  private final Object fontLock;
  // 本线程的打印锁
  private final Object thisLock;
  // 打印字符
  private final char printChar;

  public TwoLockPrinter(Object fontLock, Object thisLock, char printChar) {
    this.fontLock = fontLock;
    this.thisLock = thisLock;
    this.printChar = printChar;
  }

  @Override
  public void run() {
    // 连续打印PRINT_COUNT次
    for (int i = 0; i < PRINT_COUNT; i++) {
      // 获取前一个线程的打印锁
      synchronized (fontLock) {
        // 获取本线程的打印锁
        synchronized (thisLock) {
          //打印字符
          System.out.print(printChar);
          // 通过本线程的打印锁唤醒后面的线程
          // notify和notifyall均可,因为同一时刻只有一个线程在等待
          thisLock.notify();
        }
        // 不是最后一次则通过fontLock等待被唤醒
        // 必须要加判断,不然虽然能够打印10次,但10次后就会直接死锁
        if(i < PRINT_COUNT - 1){
          try {
            // 通过fontLock等待被唤醒
            fontLock.wait();

          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }

      }
    }
  }

  public static void main(String[] args) throws InterruptedException {
    // 打印A线程的锁
    Object lockA = new Object();
    // 打印B线程的锁
    Object lockB = new Object();
    // 打印C线程的锁
    Object lockC = new Object();

    // 打印a的线程
    Thread threadA = new Thread(new TwoLockPrinter(lockC, lockA, 'A'));
    // 打印b的线程
    Thread threadB = new Thread(new TwoLockPrinter(lockA, lockB, 'B'));
    // 打印c的线程
    Thread threadC = new Thread(new TwoLockPrinter(lockB, lockC, 'C'));

    // 依次开启a b c线程
    threadA.start();
    Thread.sleep(100); // 确保按顺序A、B、C执行
    threadB.start();
    Thread.sleep(100);
    threadC.start();
    Thread.sleep(100);
  }

}

打印结果:

ABCABCABCABCABCABCABCABCABCABC

分析:

此解法为了为了确定唤醒、等待的顺序,每一个线程必须同时持有两个对象锁,才能继续执行。一个对象锁是fontLock,就是前一个线程所持有的对象锁,还有一个就是自身对象锁thisLock。主要的思想就是,为了控制执行的顺序,必须要先持有fontLock锁,也就是前一个线程要释放掉前一个线程自身的对象锁,当前线程再去申请自身对象锁,两者兼备时打印,之后首先调用thisLock.notify()释放自身对象锁,唤醒下一个等待线程,再调用fontLock.wait()释放prev对象锁,暂停当前线程,等待再次被唤醒后进入循环。运行上述代码,可以发现三个线程循环打印ABC,共10次。程序运行的主要过程就是A线程最先运行,持有C,A对象锁,后释放A锁,唤醒B。线程B等待A锁,再申请B锁,后打印B,再释放B锁,唤醒C,线程C等待B锁,再申请C锁,后打印C,再释放C锁,唤醒A。看起来似乎没什么问题,但如果你仔细想一下,就会发现有问题,就是初始条件,三个线程按照A,B,C的顺序来启动,按照前面的思考,A唤醒B,B唤醒C,C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序,所以需要手动控制他们三个的启动顺序,即Thread.Sleep(100)。

二、通过一个ReentrantLock和三个conditon实现(推荐,安全性,性能和可读性较高)

package com.demo.test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 基于一个ReentrantLock和三个conditon实现连续打印abcabc...
 * @author lixiaoxi
 *
 */
public class RcSyncPrinter implements Runnable{

  // 打印次数
  private static final int PRINT_COUNT = 10;
  // 打印锁
  private final ReentrantLock reentrantLock;
  // 本线程打印所需的condition
  private final Condition thisCondtion;
  // 下一个线程打印所需要的condition
  private final Condition nextCondtion;
  // 打印字符
  private final char printChar;

  public RcSyncPrinter(ReentrantLock reentrantLock, Condition thisCondtion, Condition nextCondition,
      char printChar) {
    this.reentrantLock = reentrantLock;
    this.nextCondtion = nextCondition;
    this.thisCondtion = thisCondtion;
    this.printChar = printChar;
  }

  @Override
  public void run() {
    // 获取打印锁 进入临界区
    reentrantLock.lock();
    try {
      // 连续打印PRINT_COUNT次
      for (int i = 0; i < PRINT_COUNT; i++) {
        //打印字符
        System.out.print(printChar);
        // 使用nextCondition唤醒下一个线程
        // 因为只有一个线程在等待,所以signal或者signalAll都可以
        nextCondtion.signal();
        // 不是最后一次则通过thisCondtion等待被唤醒
        // 必须要加判断,不然虽然能够打印10次,但10次后就会直接死锁
        if (i < PRINT_COUNT - 1) {
          try {
            // 本线程让出锁并等待唤醒
            thisCondtion.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }

      }
    } finally {
      // 释放打印锁
      reentrantLock.unlock();
    }
  }

  public static void main(String[] args) throws InterruptedException {
    // 写锁
    ReentrantLock lock = new ReentrantLock();
    // 打印a线程的condition
    Condition conditionA = lock.newCondition();
    // 打印b线程的condition
    Condition conditionB = lock.newCondition();
    // 打印c线程的condition
    Condition conditionC = lock.newCondition();
    // 实例化A线程
    Thread printerA = new Thread(new RcSyncPrinter(lock, conditionA, conditionB, 'A'));
    // 实例化B线程
    Thread printerB = new Thread(new RcSyncPrinter(lock, conditionB, conditionC, 'B'));
    // 实例化C线程
    Thread printerC = new Thread(new RcSyncPrinter(lock, conditionC, conditionA, 'C'));
    // 依次开始A B C线程
    printerA.start();
    Thread.sleep(100);
    printerB.start();
    Thread.sleep(100);
    printerC.start();
  }
}

打印结果:

ABCABCABCABCABCABCABCABCABCABC

分析:

仔细想想本问题,既然同一时刻只能有一个线程打印字符,那我们为什么不使用一个同步锁ReentrantLock?线程之间的唤醒操作可以通过Condition实现,且Condition可以有多个,每个condition.await阻塞只能通过该condition的signal/signalall来唤醒!这是synchronized关键字所达不到的,那我们就可以给每个打印线程一个自身的condition和下一个线程的condition,每次打印字符后,调用下一个线程的condition.signal来唤醒下一个线程,然后自身再通过自己的condition.await来释放锁并等待唤醒。

三、通过一个锁和一个状态变量来实现(推荐)

package com.demo.test;

/**
 * 基于一个锁和一个状态变量实现连续打印abcabc...
 * @author lixiaoxi
 *
 */
public class StateLockPrinter {
  //状态变量
  private volatile int state=0;

  // 打印线程
  private class Printer implements Runnable {
    //打印次数
    private static final int PRINT_COUNT=10;
    //打印锁
    private final Object printLock;
    //打印标志位 和state变量相关
    private final int printFlag;
    //后继线程的线程的打印标志位,state变量相关
    private final int nextPrintFlag;
    //该线程的打印字符
    private final char printChar;
    public Printer(Object printLock, int printFlag,int nextPrintFlag, char printChar) {
      super();
      this.printLock = printLock;
      this.printFlag=printFlag;
      this.nextPrintFlag=nextPrintFlag;
      this.printChar = printChar;
    }

    @Override
    public void run() {
      //获取打印锁 进入临界区
      synchronized (printLock) {
        //连续打印PRINT_COUNT次
        for(int i=0;i<PRINT_COUNT;i++){
          //循环检验标志位 每次都阻塞然后等待唤醒
          while (state!=printFlag) {
            try {
              printLock.wait();
            } catch (InterruptedException e) {
              return;
            }
          }
          //打印字符
          System.out.print(printChar);
          //设置状态变量为下一个线程的标志位
          state=nextPrintFlag;
          //注意要notifyall,不然会死锁,因为notify只通知一个,
          //但是同时等待的是两个,如果唤醒的不是正确那个就会没人唤醒,死锁了
          printLock.notifyAll();
        }
      }
    }

  }

  public void test() throws InterruptedException{
    //锁
    Object lock=new Object();
    //打印A的线程
    Thread threadA=new Thread(new Printer(lock, 0,1, 'A'));
    //打印B的线程
    Thread threadB=new Thread(new Printer(lock, 1,2, 'B'));
    //打印C的线程
    Thread threadC=new Thread(new Printer(lock, 2,0, 'C'));
    //一次启动A B C线程
    threadA.start();
    Thread.sleep(1000);
    threadB.start();
    Thread.sleep(1000);
    threadC.start();
  }

  public static void main(String[] args) throws InterruptedException {

    StateLockPrinter print = new StateLockPrinter();
    print.test();
  }

}

打印结果:

ABCABCABCABCABCABCABCABCABCABC

分析:

状态变量是一个volatile的整型变量,0代表打印a,1代表打印b,2代表打印c,三个线程都循环检验标志位,通过阻塞前和阻塞后两次判断可以确保当前打印的正确顺序,随后线程打印字符,然后设置下一个状态字符,唤醒其它线程,然后重新进入循环。

补充题

三个Java多线程循环打印递增的数字,每个线程打印5个数值,打印周期1-75,同样的解法:

package com.demo.test;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 数字打印,三个线程同时打印数字,第一个线程打印12345,第二个线程打印678910 .........
 * @author lixiaoxi
 *
 */
public class NumberPrinter {

  //打印计数器
  private final AtomicInteger counter=new AtomicInteger(0);

  private class Printer implements Runnable{
    //总共需要打印TOTAL_PRINT_COUNT次
    private static final int TOTAL_PRINT_COUNT = 5;
    //每次打印PER_PRINT_COUNT次
    private static final int PER_PRINT_COUNT = 5;
    //打印锁
    private final ReentrantLock reentrantLock;
    //前一个线程的condition
    private final Condition afterCondition;
    //本线程的condition
    private final Condition thisCondtion;

    public Printer(ReentrantLock reentrantLock, Condition thisCondtion,Condition afterCondition) {
      super();
      this.reentrantLock = reentrantLock;
      this.afterCondition = afterCondition;
      this.thisCondtion = thisCondtion;
    }

    @Override
    public void run() {
      //进入临界区
      reentrantLock.lock();
      try {
        //循环打印TOTAL_PRINT_COUNT次
        for(int i=0;i<TOTAL_PRINT_COUNT;i++){
          //打印操作
          for(int j=0;j<PER_PRINT_COUNT;j++){
            //以原子方式将当前值加 1。
            //incrementAndGet返回的是新值(即加1后的值)
            System.out.println(counter.incrementAndGet());
          }
          //通过afterCondition通知后面线程
          afterCondition.signalAll();
          if(i < TOTAL_PRINT_COUNT - 1){
            try {
              //本线程释放锁并等待唤醒
              thisCondtion.await();
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
          }
        }
      } finally {
        reentrantLock.unlock();
      }
    }
  }

  public void test() throws InterruptedException {
    //打印锁
    ReentrantLock reentrantLock=new ReentrantLock();
    //打印A线程的Condition
    Condition conditionA=reentrantLock.newCondition();
    //打印B线程的Condition
    Condition conditionB=reentrantLock.newCondition();
    //打印C线程的Condition
    Condition conditionC=reentrantLock.newCondition();

    //打印线程A
    Thread threadA=new Thread(new Printer(reentrantLock,conditionA, conditionB));
    //打印线程B
    Thread threadB=new Thread(new Printer(reentrantLock, conditionB, conditionC));
    //打印线程C
    Thread threadC=new Thread(new Printer(reentrantLock, conditionC, conditionA));
    // 依次开启a b c线程
    threadA.start();
    Thread.sleep(100);
    threadB.start();
    Thread.sleep(100);
    threadC.start();
  }

  public static void main(String[] args) throws InterruptedException {
    NumberPrinter print = new NumberPrinter();
    print.test();
  }
}

运行结果:

2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50
52
54
56
58
60
62
64
66
68
70
72
74

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

时间: 2020-03-22

Java打印斐波那契前N项的实现示例

题外 由于idea原因 用注解test无法在控制台上输入所以写死到程序里了,版本都30.9102了为什么还是这样啊,intelJ你们该反思了!!! 用intelJ IDEA的小伙伴有遇到这种测试情况吗,如果项目上有测试用例需要自己单元测试,怎么解决控制台输入问题(@test情况下),直接改main方法的那个就算了.~~ 斐波那契的认识 斐波那契数列前2项为1,从第3项开始为该项的前2项和. eg:1,1,2,3,5,8- f(n)=f(n-1)+f(n-2) 代码参考 import org.ju

如何通过Java打印Word文档

这篇文章主要介绍了如何通过Java打印Word文档,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Java 打印Word文档 本文介绍如何在Java程序中通过物理打印机和虚拟打印机来打印Word文档的方法.文中使用了类库Spire.Doc for Java,可通过 官网下载jar文件并导入程序或者直接通过maven仓库安装导入. [示例1]通过物理打印机打印 import com.spire.doc.Document; import com.s

java实现两个线程交替打印的实例代码

使用ReentrantLock实现两个线程交替打印 实现字母在前数字在后 package com.study.pattern; import java.util.concurrent.CountDownLatch; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public c

JAVA实现连接本地打印机并打印文件的实现代码

实现代码一 import javax.print.*; import javax.print.attribute.DocAttributeSet; import javax.print.attribute.HashDocAttributeSet; import javax.print.attribute.HashPrintRequestAttributeSet; import javax.print.attribute.PrintRequestAttributeSet; import java.

java打印指定年月份的日历

本文实例为大家分享了java打印指定年月份日历的具体代码,供大家参考,具体内容如下 做了一个小的日历打印,没有使用数组,所以不能对日期进行操作,用了单个for循环打印,对初学者来说应该好理解点 工具类: import java.util.Calendar; public class DaysTool { private int year; private int month; public DaysTool(){} public DaysTool(int year ,int month){ th

java自定义异常打印内容详解

本文实例为大家分享了java自定义异常打印内容的具体代码,供大家参考,具体内容如下 背景:在开发中,我们可能会使用到自定义异常,但是,这个自定义异常在打印日志时,往往打印的内容比较多. 1.自定义异常打印内容 可以看到,虽然我们使用的是自定义异常,但是当抛出时,还是会打印出堆栈的全部信息. 2.查看源码 通过查看源码,我们可以得知,当抛出异常时,程序会调用此异常的fillInStackTrace方法,但是,大部分异常都没有对该方法做处理.基本是调用super的方法. 可以看到,此方法的父类实现,

Java打印流原理及实例详解

这篇文章主要介绍了Java打印流原理及实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 平时我们在控制台打印输出,是调用print方法和println方法完成的,这两个方法都来自于java.io.PrintStream类,该类能够方便地打印各种数据类型的值,是一种便捷的输岀方式. PrintStream类 PrintStream类,为其他输出流添加了功能,使他们能够方便的打印各种数据值表示格式. PrintStream类的特点: 只负责数

java打印出菱形图案实例详解

第一步:首先对图像进行解析 想要打印该图形必须要进行多层循环嵌套,分两个部分进行打印. 第一部分为上半部分前四行,他们是递增的关系,后半部分后三行为递减关系,由此可以得出我们需要写两个打的循环.并且由于"*"位置的关系,我们必须带入空格同时打印.所以每个部分需要两个循环控制,即两个大循环每个里面嵌套两个小循环总计四个循环. 第二部:对数字进行分析 在分析之前,我们必须明白外层循环控制行数,内层循环控制列数,因此我们需要分析他的行和列. 示例代码如下: class ForForTest

Java 中This用法的实例详解

 Java 中This用法的实例详解 用类名定义一个变量的时候,定义的只是一个引用,外面可以通过这个引用来访问这个类里面的属性和方法. 那们类里面是够也应该有一个引用来访问自己的属性和方法纳? 呵呵,Java提供了一个很好的东西,就是 this 对象,它可以在类里面来引用这个类的属性和方法.先来个简单的例子: public class ThisDemo { String name="Mick"; public void print(String name){ System.out.pr

Java中的动态和静态编译实例详解

Java中的动态和静态编译实例详解 首先,我们来说说动态和静态编译的问题. Q: java和javascript有什么区别?    总结了一下:有以下几点吧: 1.首先从运行环境来说java代码是在JVM上编译成class文件,而javascript则直接在浏览器上加载运行. 2.由第一点可看出,java代码需要编译,而javascript不需要编译. 3.从语言性质来说,java是一种高级编程语言,对变量检查要求严格,javascript只是一个简单的解释性的脚本语言,对变量检查及要求很弱.

Java中IO流 字节流实例详解

Java中IO流 字节流实例详解 IO流(输入流.输出流),又分为字节流.字符流. 流是磁盘或其它外围设备中存储的数据的源点或终点. 输入流:程序从输入流读取数据源.数据源包括外界(键盘.文件.网络-),即是将数据源读入到程序的通信通道. 输出流:程序向输出流写入数据.将程序中的数据输出到外界(显示器.打印机.文件.网络-)的通信通道. 字节流 1.InputStream.OutputStream InputStream抽象了应用程序读取数据的方式 OutputStream抽象了应用程序写出数据

Java Web请求与响应实例详解

Servlet最主要作用就是处理客户端请求并作出回应,为此,针对每次请求,Web容器在调用service()之前都会创建两个对象,分别是HttpServletRequest和HttpServletResponse.其中HttpServletRequest封装HTTP请求消息,HttpServletResponse封装HTTP响应消息.需要注意的是,Web服务器运行过程中,每个Servlet都会只创建一个实例对象,不过每次请求都会调用Servlet实例的service(ServletRequest

Java Exception 捕获和显示实例详解

Java Exception 捕获和显示实例详解 在进行Java B/S架构开发时,经常有这样的场景:后端处理业务逻辑,前端负责展示,当后端处理出现异常时,如何把错误信息展示给前台呢?错误信息栈通常很多,对开发人员查找问题比较方便,但对于客户来说,打一堆的错误信息,无疑是对他们感官的一种摧残,如何捕捉最重要的信息显示到客户端呢?该信息要求简明扼要,指向出错点,且应指明异常的类型. 在很多情况下Exception的 getMessage()方法返回空的值,如果使用该方式则会在前端显示空值.我们要显

java枚举类的构造函数实例详解

java枚举类的构造函数实例详解 首先,给出一个例题如下: enum AccountType { SAVING, FIXED, CURRENT; private AccountType() { System.out.println("It is a account type"); } } class EnumOne { public static void main(String[]args) { System.out.println(AccountType.FIXED); } } T

java 中复合机制的实例详解

java 中复合机制的实例详解 继承的缺陷 继承的缺陷是由它过于强大的功能所导致的.继承使得子类依赖于超类的实现,从这一点来说,就不符合封装的原则. 一旦超类随着版本的发布而有所变化,子类就有可能遭到破坏,即使它的代码完全没有改变. 为了说明的更加具体,假设我们现在程序中使用到了HashSet,我们需要增加一个功能,去统计这个HashSet自创建以来一共曾经添加过多少元素. 在还不知道继承的缺陷的情况下,我们设计了一个类,继承了HashSet,添加了一个属性addCount来进行统计,并且复写了

java中Iterator和ListIterator实例详解

Iterator和ListIterator的作用范围以及关系: (1) Iterator可以用于迭接口List的实现ArrayList,LinkedList以及Map等. (2) ListIterator顾名思义,就是用于迭代List实现ArrayList,LinkedList. (3) 从源码或API文档中可以看出,Iterator为ListIterator的父类. public interface ListIterator<E> extends Iterator<E> { //