用java多线程技术打印Floyd三角形

我想用两条线来打印Floyd三角形（假设一条线打印数字，另一条线打印行中的数字），如下所示

以此类推，直到最大值，在这种情况下为15

我试着跟随，但它一直在每行打印一个数字

public class MyThread extends Thread{
    static volatile int lineNumber = 1;

    public static void main(String... args) {
        PrintFloyd print = new PrintFloyd();
        Thread t1 = new Thread(new TaskHandler(print, 10), "T1");
        Thread t2 = new Thread(new TaskHandler(print, 10), "T2");
        t1.start();
        t2.start();
    }
}

class TaskHandler implements Runnable {

    static volatile int i = 1;
    static volatile int lineCount = 1;
    static volatile int lineNumber = 1;
    private int max;
    private PrintFloyd print;

    TaskHandler(PrintFloyd print2, int max) {
        this.print = print2;
        this.max = max;
    }

    @Override
    public void run() {
        System.out.println(">>>>" + Thread.currentThread().getName());
        while(i < max){
            if (Thread.currentThread().getName().equals("T1")){
                print.printNumber(i);
            } else {
                print.breakLine();
            }           
        } 
    }
}

class PrintFloyd {

    boolean isBreakPoint = false;

    public void printNumber(int i) {

        synchronized(this){
            while (isBreakPoint == false) {
                try {
                    wait();
                } catch (InterruptedException ex) {

                }
                System.out.print(i++ + " ");
                isBreakPoint = false;
                notifyAll();
            }
        }
    }

    public void breakLine(){
        synchronized(this){

            while (isBreakPoint == true) {
                try {
                    wait();
                } catch (InterruptedException ex) {

                }
            }
            System.out.println();
            isBreakPoint = true;
            notifyAll();
        }
    }
}

公共类MyThread扩展线程{
静态易失性int lineNumber=1；
公共静态void main（字符串…参数）{
PrintFloyd print=新的PrintFloyd（）；
线程t1=新线程（新任务处理器（打印，10），“t1”）；
线程t2=新线程（新任务处理器（打印，10），“t2”）；
t1.start（）；
t2.start（）；
}
}
类TaskHandler实现可运行{
静态挥发性int i=1；
静态volatile int lineCount=1；
静态易失性int lineNumber=1；
私人int max；
私人印刷；弗洛伊德印刷；
TaskHandler（PrintFloyd print2，int max）{
this.print=print2；
this.max=max；
}
@凌驾
公开募捐{
System.out.println（“>>>>”+Thread.currentThread（）.getName（））；
而（i

以下代码将有所帮助：

具有2个读取的公共类PrintPattern{

final static int MAX = 15;
final static String itemWriterName = "itemWriter";
final static String newLineWriterName = "newLineWriter";

public static void main(String[] args) {

    Printer print = new Printer(MAX);

    Thread itemWriter = new Thread(new ItemWriter(print), itemWriterName);
    itemWriter.start();
    Thread newLineWriter = new Thread(new NewLineWriter(print), newLineWriterName);
    newLineWriter.start();
}

}

类ItemWriter实现可运行{

private Printer print;

ItemWriter(Printer print) {
    this.print = print;
}

public void run() {
    while (print.current <= print.MAX) {
        print.printNumber();
    }
}

private Printer print;

NewLineWriter(Printer print) {
    this.print = print;
}

public void run() {
    while (print.current <= print.MAX) {
        print.printNewLine();
    }
}

专用打印机打印；
ItemWriter（打印机打印）{
this.print=打印；
}
公开募捐{
虽然（print.current您想这样做，还是希望有人为您编写？如果是后者，这不是StackOverflow的目的。请添加您尝试的代码编辑也不清楚您为什么需要或想要线程。如何编辑问题以添加我的code@cricket_007如何编辑我的问题？在评论部分上方有一个编辑链接，谢谢s@Surender这正是我想要的。我错误地调用了wait（）和notifyAll（）。
public final int MAX;
public int current = 1;
public int itemsInALine = 1;

Printer(int max) {
    this.MAX = max;
}

public void printNumber() {
    synchronized(this) {
        for(int i = current; i < current + itemsInALine && i <= MAX; i++) {
            System.out.print(i + " ");
        }
        this.current = current + itemsInALine;
        itemsInALine++;
        notifyAll();
        try {
            if(this.current < MAX) {
                wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public void printNewLine() {
    synchronized(this) {
        System.out.println();
        notifyAll();
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}