java基础---多线程之交替打印，等待唤醒机制

96 阅读 0 评论 64 点赞

我是靠谱客的博主哭泣花瓣，最近开发中收集的这篇文章主要介绍java基础---多线程之交替打印，等待唤醒机制，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

对于交替打印的线程问题：

方法1：非标志方法

package com.exam_1;
/*
定义一个线程A，输出1 ～ 10之间的整数，定义一个线程B，逆序输出1 ～ 10之间的整数(10)要求线程A和线程B交替输出
 */
/*
非标志位方法
 */
public class Demo04_pp {
    public static void main(String[] args){
        Object obj=new Object();//定义一个对象obj
        //将此对象分别传给A,B,也就是说ab共用一个对象
        A2 a=new A2(obj);
        B2 b=new B2(obj);
        //启动线程
        a.start();
        b.start();
    }
}

class A2 extends Thread{
    Object obj;
    public A2() {
        super();
    }
    //定义obj的构造方法
    public A2(Object obj) {
        super();
        this.obj = obj;
    }
    //正序打印
    @Override
    public void run() {
        //此时obj就是主函数中定义的obj
        synchronized (obj) {
            for(int i=1;i<11;i++){
                System.out.print(i+",");
                obj.notify();//第一次程序走到这里时，这个并没有什么用。
                try {
                    //obj  -  B等待
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class B2 extends Thread{
    Object obj;
    public B2() {
        super();
    }
    public B2(Object obj) {
        super();
        this.obj = obj;
    }
    //逆序打印
    @Override
    public void run() {
        try {
            //先让B的run方法sleep，这样最先调用的就是A的run方法
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //B中的obj也是主函数中定义的obj
        synchronized (obj) {
            for(int i=10;i>0;i--){
                System.out.print(i+",");
                obj.notify();//唤醒在此对象监视器上等待的单个线程。此时在这个对象监视器上等待的线程即为A
                if (i > 1) {
                    try {
                        obj.wait();//当输出一个数是将此线程进入wait状态，这是A线程再进来
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

package com.henu;

import java.awt.font.NumericShaper;

/*
1. 创建两个线程，其中一个输出1-52，另外一个输出A-Z。输出格式要求：12A 34B 56C 78D
 */
public class Test01 {
    public static void main(String[] args) {

        Object obj = new Object();
        Number n = new Number(obj);
        Letter l = new Letter(obj);

        n.start();
        l.start();
    }
}


class Number extends Thread{
    Object obj;
    public Number() {
    }

    public Number(Object obj) {
        this.obj = obj;
    }

    @Override
    public void run() {
        synchronized (obj){
            int i = 1;
            while(i <= 52){
                System.out.print(i);
                System.out.print(i+1);
                i += 2;
                obj.notify();
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class Letter extends Thread{
    Object obj;
    public Letter() {
    }

    public Letter(Object obj) {
        this.obj = obj;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(obj){
            for (int i = 65; i <= 90; i++) {
                System.out.print((char) i+",");
                obj.notify();
                if (i < 90) {
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

2.采用标志方法

package com.henu;
/*
编写程序实现,子线程循环3次,接着主线程循环5次,接着再子线程循环3次,主线程循环5次,如此反复,循环3次.
 */
public class Test03 {

    public static void main(String[] args) {
        final ThreadFunction2 f2 = new ThreadFunction2();

        // 子线程循环3次
        new Thread(new Runnable(){
            public void run(){
                for(int i=0;i<3;i++){
                    f2.subFunction();
                }
            }
        }).start();

        // 主线程循环3次
        for(int i=0;i<3;i++){
            f2.mainFunction();
        }
    }

}


// 编写功能类,实现子线程和主线程的功能
class ThreadFunction2 {

    private boolean flag = false;

    // 主线程要实现的功能
    public synchronized void mainFunction(){
        while(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for(int i=0;i<5;i++){
            System.out.println("mainFunction"+i);
        }
        this.notify();
        flag = false;
    }

    // 子线程要实现的功能
    public synchronized void subFunction(){
        while(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for(int i=0;i<3;i++){
            System.out.println("subFunction"+i);
        }
        this.notify();
        flag = true;
    }

}