标签: buffered

Python的解释器默认启用输出缓冲sys.stdout吗？

如果答案是肯定的,那么禁用它的所有方法是什么？

建议到目前为止:

1. 使用-u命令行开关
2. 包装sys.stdout在每次写入后刷新的对象
3. 设置PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

是否有任何其他方式来设置一些全局标志sys/ sys.stdout程序执行过程中？

有这个代码:

public class Main {
    public static void main(final String[] args) throws Exception {
        System.out.print("1");
        doAnything();
        System.out.println("2");
    }

    private static void doAnything() {
        try {
            doAnything();
        } catch (final Error e) {
            System.out.print("y");
        }
    }
}

还有输出:

1yyyyyyyy2

为什么它打印"y"八次而不再打印.遇到Java println()时如何调用StackOverflowError？

段7.9.13/7的c99规定:

在程序启动时,预定义了三个文本流,无需明确打开 - 标准输入(用于读取传统输入),标准输出(用于写入常规输出)和标准错误(用于写入诊断输出).

最初打开时,标准错误流未完全缓冲; 当且仅当可以确定流不参考交互设备时,标准输入和标准输出流被完全缓冲.

这是有道理的.如果您将标准输出推送到文件,则需要将其完全缓冲以提高效率.

但是,当你无法确定设备是非交互式的(即正常输出到终端)时,我在标准中没有提到输出是线路缓冲还是无缓冲.

我问的原因是我在这里回答我应该fflush(stdout);在两个陈述之间插入一个:

printf ("Enter number> ");
// fflush (stdout); needed ?
if (fgets (buff, sizeof(buff), stdin) == NULL) { ... }

因为我没有printf用换行符终止.任何人都可以清除这个吗？

(道歉有些冗长的介绍)

在此期间,prefaults整个大文件(> 400MB)到缓冲区缓存后加快了实际运行的应用程序的开发,我测试是否每次读4MB仍然有超过一次读取只有1MB块任何明显的好处.令人惊讶的是,较小的请求实际上变得更快.这似乎违反直觉,所以我进行了更广泛的测试.

缓冲区缓存在运行测试之前被清除(只是为了笑,我也在缓冲区中运行了一个文件.无论请求大小如何,缓冲区缓存都能提供高达2GB/s的速度,但令人惊讶的是+/- 30%随机方差).
使用的所有读取都与相同的目标缓冲区重叠ReadFile(使用FILE_FLAG_OVERLAPPED和不 使用句柄打开FILE_FLAG_NO_BUFFERING).使用的硬盘有点老,但功能齐全,NTFS的簇大小为8kB.初始运行后磁盘进行了碎片整理(6个碎片与未碎片,零差异).为了更好的数字,我也使用了更大的文件,下面的数字是读取1GB.

结果真的令人惊讶:

4MB x 256    : 5ms per request,    completion 25.8s @ ~40 MB/s
1MB x 1024   : 11.7ms per request, completion 23.3s @ ~43 MB/s
32kB x 32768 : 12.6ms per request, completion 15.5s @ ~66 MB/s
16kB x 65536 : 12.8ms per request, completion 13.5s @ ~75 MB/s

因此,这表明提交数千个请求两个簇的长度实际上比提交几百个大的连续读取更好.提交时间(ReadFile返回之前的时间)确实随着请求数量的增加而上升,但异步完成时间几乎减半.
在每种情况下,内核CPU时间大约为5-6%(在四核上,所以应该说20-30%),而异步读取正在完成,这是一个惊人的CPU数量 - 显然操作系统做了一些非也是无比的忙碌等待.在2.6 GHz时,30%的CPU持续25秒,这是"无所事事"的相当多的周期.

知道如何解释这个吗？也许这里有人对Windows重叠IO的内部工作有更深入的了解？或者,您是否可以使用ReadFile读取兆字节的数据？

我可以看到IO调度程序如何通过最小化搜索来优化多个请求,尤其是当请求是随机访问时(它们不是!).我还可以看到,在NCQ中给出一些请求,硬盘如何能够执行类似的优化.
然而,我们谈论的是荒谬的一些荒谬的小要求 - 尽管如此,它们的表现仍然超过2倍的合理要求.

旁注:明显的赢家是内存映射.我几乎倾向于添加"毫不奇怪",因为我是内存映射的忠实粉丝,但在这种情况下,它实际上让我感到惊讶,因为"请求"甚至更小,操作系统应该更不能预测和安排IO.我最初没有测试内存映射,因为它似乎反直觉,甚至可以远程竞争.那么多你的直觉,嘿.

在不同偏移处重复映射/取消映射视图几乎为零时间.使用16MB视图并使用简单的for()循环对每个页面进行错误操作,每页读取一个字节,在9.2秒内完成@~111 …

我想使用缓冲流,因为我想使用一个peek()方法来提前查看,但使用我的流与另一个需要类文件对象的方法.(我使用seek()但可能必须处理不支持随机访问的管道输入I/O.)

但是这个测试用例失败了:

AttributeError:'file'对象没有属性'_checkReadable'

import sys
import io

srcfile = sys.argv[1]
with open(srcfile, 'rb') as f:
    fbuf = io.BufferedReader(f)
    print fbuf.read(20)

发生了什么,我该如何解决？我以为BufferedReader旨在缓冲流.如果是这样,为什么open()函数不会返回与它兼容的东西？

我很抱歉,如果这是重复但我无法找到确定答案,每种类型的最佳做法.

我想知道什么是适当的条件定义何时使用BufferedReader与FileReader或BufferedInput/OutputStream与FileInput/OutputStream？是否有一个总是告诉你什么是合适的种类的公式？

我应该只使用缓冲吗？

谢谢

我正在使用缓冲读取器从文本文件中一次抓取一行.我也试图使用跟踪整数从文本文件中获取行号.不幸的是BufferedReader正在跳过空行(只有/ n或回车).

有没有更好的方法来解决这个问题？会使用扫描仪吗？

示例代码:

int lineNumber = 0;
while ((s = br.readLine()) != null) {
    this.charSequence.add(s, ++lineNumber);
}

我正在尝试 Go 通道，但遇到一个问题，下面的简单程序不会终止。

本质上我想发出一些异步 HTTP get 请求，然后等待它们全部完成。我正在使用缓冲通道，但我不确定这是惯用的方式。

func GetPrice(quotes chan string) {
    client := &http.Client{}
    req, _ := http.NewRequest("GET", "https://some/api", nil)
    req.Header.Set("Accept", "application/json")
    res, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()
    body, err := ioutil.ReadAll(res.Body)
    quotes <- string(body)
}

func main() {
    const max = 3
    quotes := make(chan string, max)
    for i := 0; i < max; i++ {
        go GetPrice(quotes)
    }

    for n := range quotes {
        fmt.Printf("\n%s", n) …

我有一个日志文件,每秒更新一次.我需要定期读取日志文件,一旦我做了阅读,我需要存储的文件指针位置在最后一行我读的结束,并在下次定期读我应该从这一点开始.

目前,我在Java中使用随机访问文件,并使用该getFilePointer()方法获取偏移值,并使用seek()方法转到偏移位置.

但是,我已阅读大多数文章甚至Java doc建议,BufferredReader以便有效地阅读文件.如何使用a实现此目的(获取文件指针并移动到最后一行)BufferedReader,还是有其他有效的方法来实现此任务？

我需要将1027*768位图渲染到客户端窗口(相同大小),并且我没有超过10-15 ms来完成此任务.我使用bufferedGraphics从分配bufferedGraphicsContect对象,仍然看到巨大的性能问题.

我使用不安全的代码来执行我的复制操作,并找到了令人难以置信的结果.我知道Graphics/BufferedGraphics对象应该在内存中有某种绘图表面.我想知道是否有人能指出我如何使用Marshal或其他一些不安全的低级方法写入这个表面的正确方向.

我正在移植旧的c#图形应用程序.我知道c#不是为重型图形设计的,并且有比GDI +更好的工具,不幸的是我没有那些奢侈品.

这就是我到目前为止所提出的......任何有用的见解都是非常有用的.

byte[] _argbs = null;
static readonly Bitmap _bmUnderlay = Properties.Resources.bg;
static Bitmap _bmpRender = new Bitmap(1024, 768, System.Drawing.Imaging.PixelFormat.Format24bppRgb); 
int bmpHeight = Properties.Resources.bg.Height;
int bmpWidth = Properties.Resources.bg.Width;
static BufferedGraphicsContext _bgc = new BufferedGraphicsContext();

internal unsafe void FillBackBuffer(Point cameraPos)
{
        // lock up the parts of the original image to read (parts of it)
        System.Drawing.Imaging.BitmapData bmd = _bmUnderlay.LockBits(
            new Rectangle(cameraPos.X, cameraPos.Y, 1024, …