首页 \ 问答 \ 在课堂上使用特征，为什么？(Using traits over classes, why?)

在课堂上使用特征，为什么？(Using traits over classes, why?)

 这是课程的方式吗？  
Class Main 
{
    $this->a = new A();
    $this->b = new B();
    $this->c = new C();

    $this->b->doTranslate($this->a->saySomething());
}
 
 这就是特质如何做到的，不是吗？  
Class Main {
    use A;
    use B;
    use C;

    $this->doTranslate($this->saySomething());
}
 
 我根本没有太多关于特征的知识，但是通过查看新的PHP 5.4特征示例，它们似乎只对单个案例有帮助。 A class only be extended once to use $this together, but we can use multiple traits.  
 问题1：使用特征而不是基本类是否是唯一的优势？  
 问题2：如果trait A, B, and C都有一个名为example()的函数，当我尝试$this->example(); PHP将如何确定将使用哪种特性？ 会发生什么事？  
 另外，不要写一面文字; 只是给我一个简短的代码示例，简短的简介，我可以看看和承担。 我不熟悉特质，也不知道它们到底是什么。 

This is how classes do it? 
Class Main 
{
    $this->a = new A();
    $this->b = new B();
    $this->c = new C();

    $this->b->doTranslate($this->a->saySomething());
}
 
And this is how traits do it, not? 
Class Main {
    use A;
    use B;
    use C;

    $this->doTranslate($this->saySomething());
}
 
I don't have much knowledge about traits at all, but by looking at new PHP 5.4 trait examples, they only seem to help in a single case. A class only be extended once to use $this together, but we can use multiple traits. 
Question 1: Is it the only advantage of using traits over basic classes? 
Question 2: If trait A, B, and C all have a function named example(), when I try $this->example(); how PHP is going to determine which trait will be used? What's going to happen? 
Additionally, instead of writing a wall of text; just provive me a short code example with a short brief that I can have a look and undertstand. I'm not familiar with traits and don't know what they truly are.

原文：https://stackoverflow.com/questions/15164600

更新时间：2021-12-12 20:12

最满意答案

 我知道你想要非阻塞的NIO，但如果你想要一个高性能的NIO服务器，我会从这个开始作为一个基线，如果没有其他原因而不是简单。 通常最简单的也是最快的。  
package example.nio;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NioEchoServer implements Runnable, Closeable {
    private final ExecutorService service = Executors.newCachedThreadPool();
    private final ServerSocketChannel ssc;
    private volatile boolean closed = false;

    public NioEchoServer(int port) throws IOException {
        ssc = ServerSocketChannel.open();
        ssc.socket().setReuseAddress(true);
        ssc.bind(new InetSocketAddress(port));
        service.submit(this);
    }

    @Override
    public void run() {
        try {
            while (!closed) {
                SocketChannel sc = ssc.accept();
                service.submit(new EchoHandler(sc));
            }
        } catch (IOException e) {
            if (!closed)
                e.printStackTrace();
        } finally {
            closeQuietly(ssc);
        }
    }

    @Override
    public void close() throws IOException {
        closed = true;
        service.shutdownNow();
        closeQuietly(ssc);
    }

    static void closeQuietly(Closeable closeable) {
        try {
            if (closeable != null) closeable.close();
        } catch (IOException ignored) {
        }
    }

    public int getPort() {
        return ssc.socket().getLocalPort();
    }

    static class EchoHandler implements Runnable {
        private final SocketChannel sc;

        public EchoHandler(SocketChannel sc) {
            this.sc = sc;
        }

        @Override
        public void run() {
            ByteBuffer bb = ByteBuffer.allocateDirect(64 * 1024);
            try {
                while (!Thread.interrupted() && sc.read(bb) > 0) {
                    int len = bb.position();
                    bb.flip();
                    while (bb.remaining() > 0)
                       sc.write(bb);
                    // write everything a second time.
                    bb.position(0);
                    bb.limit(len);
                    while (bb.remaining() > 0)
                        sc.write(bb);

                    bb.clear();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Server disconnected");
                closeQuietly(sc);
            }
        }
    }
}
 
 
package example.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.atomic.AtomicLong;

public class NioEchoClient {
    public static void main(String... arg) throws IOException, InterruptedException {
        NioEchoServer nes = new NioEchoServer(0); // use a free port.
        final SocketChannel sc = SocketChannel.open(new InetSocketAddress("localhost", nes.getPort()));
        // send data for 2 seconds.
        long writeCount = 0;
        final AtomicLong readCount = new AtomicLong();
        long start = System.currentTimeMillis();
        long end = start + 2000;
        Thread reader = new Thread(new Runnable() {
            @Override
            public void run() {
                ByteBuffer bb = ByteBuffer.allocateDirect(64 * 1024);
                bb.clear();
                int read;
                try {
                    while ((read = sc.read(bb)) > 0) {
                        bb.clear();
                        readCount.addAndGet(read);
                    }
                } catch (IOException ignored) {
                }
            }
        });
        reader.start();
        ByteBuffer bb = ByteBuffer.allocateDirect(64 * 1024);
        while (end > System.currentTimeMillis()) {
            bb.clear();
            int write = sc.write(bb);
            if (write < 0)
                throw new AssertionError("Unexpected disconnection?");
            writeCount += write;
        }
        sc.shutdownOutput();
        reader.join();
        long time = System.currentTimeMillis() - start;
        System.out.printf("Wrote: %,d bytes and read: %,d bytes in %,d ms%n",
                writeCount, readCount.get(), time);
        sc.close();
        nes.close();
    }
}
 
 版画  
Wrote: 186,318,848 bytes and read: 186,318,848 bytes in 2,001 ms
 
 当我写的两倍于我读的时候  
Wrote: 118,161,408 bytes and read: 236,322,816 bytes in 2,002 ms

I know you want non-blocking NIO, but if you want a performant NIO server I would start with this as a base line if for no other reason than simplicity. Often the simplest is also the fastest. 
package example.nio;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NioEchoServer implements Runnable, Closeable {
    private final ExecutorService service = Executors.newCachedThreadPool();
    private final ServerSocketChannel ssc;
    private volatile boolean closed = false;

    public NioEchoServer(int port) throws IOException {
        ssc = ServerSocketChannel.open();
        ssc.socket().setReuseAddress(true);
        ssc.bind(new InetSocketAddress(port));
        service.submit(this);
    }

    @Override
    public void run() {
        try {
            while (!closed) {
                SocketChannel sc = ssc.accept();
                service.submit(new EchoHandler(sc));
            }
        } catch (IOException e) {
            if (!closed)
                e.printStackTrace();
        } finally {
            closeQuietly(ssc);
        }
    }

    @Override
    public void close() throws IOException {
        closed = true;
        service.shutdownNow();
        closeQuietly(ssc);
    }

    static void closeQuietly(Closeable closeable) {
        try {
            if (closeable != null) closeable.close();
        } catch (IOException ignored) {
        }
    }

    public int getPort() {
        return ssc.socket().getLocalPort();
    }

    static class EchoHandler implements Runnable {
        private final SocketChannel sc;

        public EchoHandler(SocketChannel sc) {
            this.sc = sc;
        }

        @Override
        public void run() {
            ByteBuffer bb = ByteBuffer.allocateDirect(64 * 1024);
            try {
                while (!Thread.interrupted() && sc.read(bb) > 0) {
                    int len = bb.position();
                    bb.flip();
                    while (bb.remaining() > 0)
                       sc.write(bb);
                    // write everything a second time.
                    bb.position(0);
                    bb.limit(len);
                    while (bb.remaining() > 0)
                        sc.write(bb);

                    bb.clear();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Server disconnected");
                closeQuietly(sc);
            }
        }
    }
}
 
 
package example.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.atomic.AtomicLong;

public class NioEchoClient {
    public static void main(String... arg) throws IOException, InterruptedException {
        NioEchoServer nes = new NioEchoServer(0); // use a free port.
        final SocketChannel sc = SocketChannel.open(new InetSocketAddress("localhost", nes.getPort()));
        // send data for 2 seconds.
        long writeCount = 0;
        final AtomicLong readCount = new AtomicLong();
        long start = System.currentTimeMillis();
        long end = start + 2000;
        Thread reader = new Thread(new Runnable() {
            @Override
            public void run() {
                ByteBuffer bb = ByteBuffer.allocateDirect(64 * 1024);
                bb.clear();
                int read;
                try {
                    while ((read = sc.read(bb)) > 0) {
                        bb.clear();
                        readCount.addAndGet(read);
                    }
                } catch (IOException ignored) {
                }
            }
        });
        reader.start();
        ByteBuffer bb = ByteBuffer.allocateDirect(64 * 1024);
        while (end > System.currentTimeMillis()) {
            bb.clear();
            int write = sc.write(bb);
            if (write < 0)
                throw new AssertionError("Unexpected disconnection?");
            writeCount += write;
        }
        sc.shutdownOutput();
        reader.join();
        long time = System.currentTimeMillis() - start;
        System.out.printf("Wrote: %,d bytes and read: %,d bytes in %,d ms%n",
                writeCount, readCount.get(), time);
        sc.close();
        nes.close();
    }
}
 
prints 
Wrote: 186,318,848 bytes and read: 186,318,848 bytes in 2,001 ms
 
when I write twice as much as I read I get 
Wrote: 118,161,408 bytes and read: 236,322,816 bytes in 2,002 ms

在课堂上使用特征，为什么？(Using traits over classes, why?)

最满意答案

相关问答

在阅读和写作之后`std :: stringstream :: fail（）`返回什么值？(What value should `std::stringstream::fail()` return after reading then writing? (gcc vs clang))[2023-12-06]

Berkeley DB读取数据失败(Berkeley DB Reading a data fail)[2024-04-02]

在没有先选择的情况下在其他表格中读取/写入数据(Reading/Writing Data In Other Sheets Without Selecting First)[2022-10-19]

如何知道哪个应用程序正在读取或写入文件(How to know which application is reading or writing file)[2022-03-07]

写完后读取文件(Reading file after writing it)[2022-09-28]

顺序写入和读取数据到EEPROM(Writing and Reading data to EEPROM sequentially)[2021-05-04]

在Pebble上读取和写入持久数据(Reading and writing persistent data on Pebble)[2022-04-06]

使用Java NIO读取和写入大文件(Reading and writting a large file using Java NIO)[2024-03-21]

写入更多数据而不是读取时，NIO会失败(NIO fail when writing more data than reading)[2023-08-05]

在Firebase中读取和写入数据(Reading and writing data in Firebase)[2022-03-04]

相关文章

最新问答