printf在Linux上使用线程安全写入stdout ？使用低级write命令怎么样？

请考虑这个java代码:

public class CMain {
    public static void main(String[] args){

        for (int i = 0; i < 10; i++) {
            System.out.println("A");
            System.err.println("B");
        }

    }
}

通过快速查看代码,我们中的一些人可能认为输出必须是As和Bs的印刷品.不过不是!它是10个字符和10个B字符的随机外观.像这样的东西:

这是为什么？什么是它的解决方案,以便As和Bs交替显示(ABABAB ...)在我问这个问题之前,我检查了其他几个类似的问题以寻求解决方案,而不是为我的案例工作!我带来了一些在这里:

• 同步和System.out.println
• Java:同步标准输出和标准错误
• Java:System.out.println和System.err.println乱序 PS.我使用Eclipse作为我的IDE

基本上,我想知道哪种方法更好,

for(int i = 0; i < 10000; i++){
    System.out.print("blah");
}
System.out.println("");

要么

String over_9000_blahs = "";
for(int i = 0; i < 10000; i++){
    over_9000_blahs += "blah";
}
System.out.println(over_9000_blahs);

还是有更好的方法,我不知道？

System.out返回"标准"输出流 - a PrintStream.该javadoc的的PrintStream告诉我任何关于线程安全的,但看源的OpenJDK和OracleJDK告诉我,println是同步的.

/**
 * Prints a String and then terminate the line.  This method behaves as
 * though it invokes <code>{@link #print(String)}</code> and then
 * <code>{@link #println()}</code>.
 *
 * @param x  The <code>String</code> to be printed.
 */
public void println(String x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

这非常适合我的经验:System.out.println()从不同的线程调用时,调用从未创建"混合"输出.

所以我的问题:

1. 我可以依赖这种行为(使用不同的JVM)吗？
2. 是否有一些我遗漏的文档描述了这种行为？

您好我是java编程的初学者,最近我正在学习Threads,我在这个程序的输出中遇到问题.

class s1 implements Runnable 
{ 
    int x = 0, y = 0; 
    int addX() {x++; return x;} 
    int addY() {y++; return y;} 
    public void run() { 
        for(int i = 0; i < 10; i++){ 
            System.out.println(addX() + " " + addY()); 
        }
    } 
    public static void main(String args[]) 
    { 
        s1 run1 = new s1(); 
        s1 run2 = new s1(); 
        Thread t1 = new Thread(run1); 
        Thread t2 = new Thread(run2); 
        t1.start(); 
        t2.start(); 
    } 
}

我得到这样的输出,

1 1 2 2 1 1 …

我有以下代码:

public class MyApp {
    public static void main(String[] args) throws InterruptedException {
        SharedResource sharedResource = new SharedResource();

        Runnable first = () -> {
            sharedResource.increment(10000);
        };

        Runnable second = () -> {
            sharedResource.increment(10000);
        };

        Thread thread = new Thread(first, "FirstThread");
        Thread thread2 = new Thread(second, "SecondThread");
        thread.start();
        thread2.start();
        thread.join();
        thread2.join();
        System.out.println("The value of counter is " + sharedResource.getCounter());
    }
}

使用这个类:

public class SharedResource {
    private int counter;

    public void increment(int times) {
        for (int x=1; x<=times;x++) {
            counter++;
            // …

为了练习JavaFX,我构建了一个绘制Sierpinski Triangles的简单应用程序.

import javafx.application.Application;
import javafx.application.Platform;
import javafx.concurrent.Task;
import javafx.geometry.Insets;
import javafx.geometry.Point2D;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.layout.AnchorPane;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

public class SierpinskiTriangles extends Application {

    private final int PADDING = 5;
    private static int numberOfLevels;

    public static void launch(String... args){

        numberOfLevels = 8;

        if((args != null) && (args.length > 0)) {

            int num = -1;
            try {
                num = Integer.parseInt(args[0]);
            } catch (NumberFormatException ex) {
                            ex.printStackTrace();
                return; …

public class ThreadDemo {

public static void main(String args[]) throws Exception {
    Printer[] printers = new Printer[5];
    printers[0] = new Printer("@base");
    printers[1] = new Printer("#try");
    printers[2] = new Printer("!test");
    printers[3] = new Printer("^hello");
    printers[4] = new Printer("*world");

    for (Printer x : printers) {
        x.start();
    }

    try {
        for (Printer y : printers) {
            y.join();
        }
    } catch (InterruptedException e) {
        System.out.println(e);
    }
  }
}

class Printer extends Thread {
public Printer(String name) {
    super(name);
}

public void run() {
    print(); …

为什么使用logger.debug()而不是System.out.println()？

据我所知,log4j的允许您控制要打印(什么DEBUG,FATAL,INFO,等),但除此之外,还有没有其他的好处？

当println在Clojure中并发调用时，我发现它的行为与Java的行为不同System.out.println。

我会用Java写什么

class Pcalls {
    public static void main(String[] args) {
        Runnable[] fns = new Runnable[3];
        for (int i = 0; i < 3; i++) {
            fns[i] = new Runnable() {
                @Override public void run() {
                    for (int i = 1; i <= 5; i++) {
                        System.out.println("Hello iteration " + i);
                    }
                }
            };
        }
        for (Runnable fn : fns) new Thread(fn).start();
    }
}

我在Clojure中解释为：

(doall (apply pcalls
              (repeat 3 #(dotimes [i 5] (println "Hello iteration" …

我需要一些帮助才能完全理解运行此代码时发生的情况

public class Main extends Thread {

    private static int x;

    public static void main(String[] args) {
        Thread th1 = new Main("A");
        Thread th2 = new Main("B");
        th1.start();
        th2.start();
    }

    public Main(String n) {
        super(n);
    }

    public void run() {
        while(x<4) {   //1
            x++;       //2
            System.out.print(Thread.currentThread().getName()+x+" ");   //3
        }
    }
}

我得到了输出

B2 B3 B4 A2 

我理解线程A并且B都增加x,然后B循环递增和输出......但为什么是最后输出A2？不应该A看x作为4执行的时候//3？

奖金问题:为什么不能x成为5？

编辑

这个问题(略有不同的形式)来自OCP认证的模拟测试,其中解释说x …