OK，改个名字，只想知道第一题的详细答案，其他我也能说出一二，别鸡鸡爪爪的，没素质

1、多进程读写文件：一个进程A写文件file，另一个进程B读文件file


2、解释二叉树，二叉树的特征，在二叉树最后增加一个叶子节点


3、操作系统相关知识


4、数据结构：解释队列和栈，它们之间的区别


5、解释左外连，A表左外连B表它得到的结果集是什么

1.考核线程同步以及缓冲知识点。
2.先序，中序，后序编历问题。也就是什么左中右，中左右，左右中问题，不多说。
3.基本不多说
4.Java中是stack,queue(ArrayBlockinkQueue等)。然后说一下后进先出，先进先出等概念完事。基本，不解释。
5.就是保持左表数据和交集。左连，右连，内连等概念，不多说。

结论，你的水平很差。

就你这么回答照样被BS。。。

那你倒说说？装什么B。我又不是没面过中兴,offer以前也拒了。

请牛哥绕道，我只是给大家共享一下，因为我在数据结构和操作系统方面并不是知道太多
水平是差，没办法

面的什么职位？

是你在装，要会你就答明白了，要不就别答，第二题还省去前半部分，没别的意思，想回答就认真回答，别随便答几句就说别人怎么样。全都答个不多说，那你干脆就别说。
表面你要表示这些题你都会，可回答又闪烁其词，这算什么呢？认为自己实力强就好好回答呗

顶这个，说的在理，什么不解释，不多说，能给别人有益的帮助么？

leibos兄的确有点浮躁了。。。。。。。

多进程读写文件：一个进程A写文件file，另一个进程B读文件file
Doug Lea 在他的书中提供一个示例代码
ReadWrite 为抽象类，允许并发的读操作，不允许并发的写操作，也不允许读写同时进行。
可以扩展ReadWrite为SingleFileReadWrite 实现 doRead和doWrite方法来读写文件
线程A和线程B使用同一个SingleFileReadWrite 实例
SingleFileReadWrite rw;
threadB rw.read();
threadA rw.write();

abstract class ReadWrite {
 protected int activeReaders = 0;  // threads executing read
 protected int activeWriters = 0;  // always zero or one

 protected int waitingReaders = 0; // threads not yet in read
 protected int waitingWriters = 0; // same for write

 protected abstract void doRead(); // implement in subclasses
 protected abstract void doWrite();

 public void read() throws InterruptedException {
  beforeRead();
  try   { doRead(); }
  finally { afterRead(); }
 }

 public void write() throws InterruptedException {
  beforeWrite();
  try     { doWrite(); }
  finally { afterWrite(); }
 }
 protected boolean allowReader() {
  return waitingWriters == 0 && activeWriters == 0;
 }

 protected boolean allowWriter() {
  return activeReaders == 0 && activeWriters == 0;
 }

 protected synchronized void beforeRead()
  throws InterruptedException {
   ++waitingReaders;
   while (!allowReader()) {
    try { wait(); }
    catch (InterruptedException ie) {
      --waitingReaders; // roll back state
      throw ie;
    }
  }
  --waitingReaders;
  ++activeReaders;
 }

 protected synchronized void afterRead()  {
  --activeReaders;
  notifyAll();
 }

 protected synchronized void beforeWrite()
  throws InterruptedException {
   ++waitingWriters;
   while (!allowWriter()) {
    try { wait(); }
    catch (InterruptedException ie) {
     --waitingWriters;
     throw ie;
    }
   }
   --waitingWriters;
   ++activeWriters;
 }

 protected synchronized void afterWrite() {
  --activeWriters;
  notifyAll();
  }
}