System.out.println( )对性能影响_福尔摩帅的博客

直接上代码

  <textarea readonly="readonly" name="code" class="Java"> 
  * 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();
/**  * 如果是一个对象，则会多一句代码String s = String.valueOf(x);
     * Prints an Object and then terminate the line.  This method calls
     * at first String.valueOf(x) to get the printed object's string value,
     * then behaves as
     * though it invokes <code>{@link #print(String)}</code> and then
     * <code>{@link #println()}</code>.
     * @param x  The <code>Object</code> to be printed.
    public void println(Object x) {
        String s = String.valueOf(x);
        // 该方法是一个synchronized的方法，首先打印字符，然后换一行。
        synchronized (this) {
            print(s);
            // newLine()也是一个synchronized的方法
            newLine();
/**  * 多出的这一句代码实质上是调用了对象的toString()方法并做了空判断
     * Returns the string representation of the {@code Object} argument.
     * @param   obj   an {@code Object}.
     * @return  if the argument is {@code null}, then a string equal to
     *          {@code "null"}; otherwise, the value of
     *          {@code obj.toString()} is returned.
     * @see     java.lang.Object#toString()
    public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
/**  * 也许你以为newLine()方法只是打印一个\n，但是实际上，他却是这样的
     * 其中textOut.flushBuffer();也是一个synchronized方法
     * 如果在这个过程中发生了IO中断异常，newLine()方法会中断掉当前线程
private void newLine() {
        try {
            synchronized (this) {
                ensureOpen();
                textOut.newLine();
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush)
                    out.flush();
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        catch (IOException x) {
            trouble = true;
/**  * 将输出缓冲区刷新到基础字符流
     * Flushes the output buffer to the underlying character stream, without
     * flushing the stream itself.  This method is non-private only so that it
     * may be invoked by PrintStream.
    void flushBuffer() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (nextChar == 0)
                return;
            out.write(cb, 0, nextChar);
            nextChar = 0;
/**  * 打印字符，如果字符不为空的话
     * Prints a string.  If the argument is <code>null</code> then the string
     * <code>"null"</code> is printed.  Otherwise, the string's characters are
     * converted into bytes according to the platform's default character
     * encoding, and these bytes are written in exactly the manner of the
     * <code>{@link #write(int)}</code> method.
     * @param      s   The <code>String</code> to be printed
    public void print(String s) {
        if (s == null) {
            s = "null";
        write(s);
/**  * 输出字符的write方法和newLine动作其实是一致的
     * System.out.println()标准输出方法其实相当于print()方法调用两次
private void write(String s) {
        try {
            synchronized (this) {
                ensureOpen();
                // textOut是BufferedWriter的一个对象，该类继承至Object以及Writer类
                // 该类是一个抽象类，作用是向字符流中执行写入。
                textOut.write(s);
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush && (s.indexOf('\n') >= 0))
                    out.flush();
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        catch (IOException x) {
            trouble = true;
/**  * textOut.write(s);调用的是该方法
     * 但是该方法只是把字符拆分一些信息来传递参数
     * Writes a string.
     * @param  str
     *         String to be written
     * @throws  IOException
     *          If an I/O error occurs
    public void write(String str) throws IOException {
        write(str, 0, str.length());
/**  * 该方法也是synchronized的
     * lock其实是this，通过this.lock=this获得
     * Writes a portion of a string.
     * @param  str
     *         A String
     * @param  off
     *         Offset from which to start writing characters
     * @param  len
     *         Number of characters to write
     * @throws  IndexOutOfBoundsException
     *          If <tt>off</tt> is negative, or <tt>len</tt> is negative,
     *          or <tt>off+len</tt> is negative or greater than the length
     *          of the given string
     * @throws  IOException
     *          If an I/O error occurs
    public void write(String str, int off, int len) throws IOException {
        synchronized (lock) {
            char cbuf[];
            if (len <= WRITE_BUFFER_SIZE) {
                if (writeBuffer == null) {
                    writeBuffer = new char[WRITE_BUFFER_SIZE];
                cbuf = writeBuffer;
            } else {    // Don't permanently allocate very large buffers.
                cbuf = new char[len];
            str.getChars(off, (off + len), cbuf, 0);
            write(cbuf, 0, len);
看到synchronized就知道了，太凶残了直接加了这个重量级线程锁。syso在当前线程，必须写完才继续下面的程序！ 
GG，思密达！
                      在项目开发中，查看输出值，简单调试或许会用到System.out.println()方法。但是正式上线项目，切记不要闲来无事写几个System.out.println()，轻则会使性能受影响重则让服务器瘫痪。直接上代码  &amp;lt;textarea readonly=&quot;readonly&quot; name=&quot;code&quot; class=&quot;Java&quot;&amp;gt;   * Prints a String and ...
				Freebencher 是一个极其灵活易用的性能测试工具。之所以灵活，是因为你可以用任意 Java 代码来写性能测试用例，你可以测试任何可以用 Java 代码来表示的行为，你可以用任何你自己喜欢的方式在测试时获取你的测试数据。 
	生成的结果类似于 apache ab 的结果, 使用你喜欢的 concurrency，qps 等概念。
	你可以通过 Maven 把 freebencer 迅速导入到你的项目中，调用你自己的业务方法，而不是像 Jmeter 一样，把你的类文件别扭地复制到它的目录中。
	例：    @Test
    public void testLogin() {
        final List userList = new ArrayList();
        ...//preparing userList to be used as test data.
        FbJobResult result = Freebencher.benchmark(new FbTarget() { //the behavior
            @Override
            public boolean invoke() {
                User user = userList.get(RandomUtils
                        .nextInt(userList.size()));
                int statusCode = remoteServiceToTest.doLogin(user.getUsername(), user.getClearPassword());
                return statusCode == 200;
        }, 5, // concurrency,
                50 // number of tests to run
        System.out.println(result.report());
    }得到结果：Test started.
Awaiting termination...
Test completed.
Concurrency:             5
Time taken for tests:    119ms
Successful tests:        50
Failed tests:            0
Tests per second:        420.16806722689074
Mean time per test:      11.38ms
Percentage of the test finished within a certain time (ms)
50%:                     11
60%:                     12
70%:                     12
80%:                     13
90%:                     14
95%:                     14
98%:                     14
99%:                     16
100%:                    16
                            标签：freebencher  性能测试
				讲讲你不知道的System.out.println
在开发或者调试bug的过程中，有些同学经常用到System.out.println语句，输出到控制台，用来查看数据是否正常。
开发或者调试完毕，很可能就忘记删除，直接就发布到生产中去了。
在一些对性能要求比较高的项目当中，忘记删除的这些代码，就成为将为需要清除优化的对象了。
System.out.println 这个语句 对性能有影响吗？答案是肯定的，下面用实例给大家验证一下：
public class Test01 {
				问题：在java项目中使用system.out来打印调试信息很方便，项目上线时QA说system.out非常影响服务性能，建议全去掉。
原因：system.out 和java运行程序运行在同一线程，也就是说，业务程序会等待system.out的动作，导致资源被占用。
解决办法:改用log4j 等工具进行调试信息的打印。这类工具是异步线程的，不会使程序处于等待状态。
参考：System.out...
				System.out.println()标准输出方法性能影响一窥#以前在写功能性代码的时候就知道，代码功能性的强大往往意味着性能的丢失。那么非常好用支持任何格式输出到控制台的System.out.println()标准输出方法究竟是如何工作的呢？做一个简单的测试public class TestOut {
    private static long timeOut = System.curren
这两天在验证问题的时候, 突然发现一个问题System.out.println( ) 会影响测试的准确性,
因为System.out.println( ) 本来性能就很差!!!!!!\
所以特意做了个性能测试.
二.测试代码
				List list = new ArrayList&lt;Object&gt;();
		long t = System.currentTimeMillis();
		for (int i = 0; i &lt; 100000; i++) {
			list.add("sssss-:" + i);
		long t1 = System.currentTimeMillis();
				先说一下之前对System.out.println的误会先举个例子package com.yigjn.Thread;
public class MyThread extends Thread {
	private int count = 0;
	@Override
	public void run() {
		 for (int i = 0; i &lt; 10000; i++) {  
public void update() { 
    logger.info("开始测试修改"); // 使用日志工具代替 System.out.println()
    Student student = studentDao.getById(3); // 先查询此数据是否存在
    if (student != null) {
        studentDao.batchUpdate(studentList); // 批量更新