多线程并发依次打印ABC问题

已于 2022-11-29 15:01:24 修改
阅读量584 收藏
点赞数
文章标签： java
于 2022-07-14 17:49:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31849075/article/details/125789487
版权

三线程打印ABC的问题了吧，这是一道比较经典的面试题

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。

代码如下：

import Book.Book;

import java.util.ArrayList;
import java.util.List;

public class MyThreadPrinter2 implements Runnable {

    private String name;
    private Book prev;
    private Book self;
    private static List<Thread> list=new ArrayList<Thread>();


    private void addr(MyThreadPrinter2 t){
        list.add(new Thread(t));
    }
    private MyThreadPrinter2(String name, Book prev, Book self) {
        this.name = name;
        this.prev = prev;
        this.self = self;
        list.add(new Thread(this));
    }

    @Override
    public void run() {
        int count = 10;
        while (count > 0) {
            synchronized (prev) {
                synchronized (self) {
                    System.out.println("第"+(11-count)+"打印:"+name);
                    count--;
                    self.notify();
                    for(Thread l:list){
                        System.out.println("线程"+l.getName()+l.getState());
                    }
                }
                try {
                    prev.wait();
                    for(Thread l:list){
                        System.out.println("线程"+l.getName()+l.getState());
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

    public static void main(String[] args) throws Exception {
        Book a=new BookA();
        Book b=new BookB();
        Book c=new BookC();
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);
        for(Thread t:list){
            t.start();
            Thread.sleep(100);
        }
    }
}

第1打印:A
线程Thread-0RUNNABLE  打印A 线程1运行状态
线程Thread-1NEW
线程Thread-2NEW
第1打印:B
线程Thread-0WAITING   打印B,线程1进入等待
线程Thread-1RUNNABLE
线程Thread-2NEW
第1打印:C
线程Thread-0BLOCKED   锁1
线程Thread-1WAITING
线程Thread-2RUNNABLE

线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第2打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING

线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第2打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第2打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第3打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第3打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第3打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第4打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第4打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第4打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第5打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第5打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第5打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第6打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第6打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第6打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第7打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第7打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第7打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第8打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第8打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第8打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第9打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第9打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第9打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
第10打印:A
线程Thread-0RUNNABLE
线程Thread-1BLOCKED
线程Thread-2WAITING
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2WAITING
第10打印:B
线程Thread-0WAITING
线程Thread-1RUNNABLE
线程Thread-2BLOCKED
线程Thread-0WAITING
线程Thread-1WAITING
线程Thread-2RUNNABLE
第10打印:C
线程Thread-0BLOCKED
线程Thread-1WAITING
线程Thread-2RUNNABLE
线程Thread-0RUNNABLE
线程Thread-1WAITING
线程Thread-2WAITING
 

       可以看出：三线程打印ABC，打印A，锁B，C等待；依次为当前线程打印，下一个线程上锁，下下个线程等待，打印完毕释放B锁，B进入打印状态，锁C...

      可以转换理解为程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。

wait和sleep区别

共同点：

    1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
    1. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。 如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。 需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。

不同点：

    1. Thread类的方法：sleep(),yield()等 Object的方法：wait()和notify()等
    1. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
    1. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

所以sleep()和wait()方法的最大区别是：

  • msleep()睡眠时，保持对象锁，仍然占有该锁；
  • 而wait()睡眠时，释放对象锁。
  • 但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

sleep（）方法

  • sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
  • sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
  • 在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。

wait（）方法

  • wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
  • wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
  • wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
乘风2022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值