选择debug之后显示这个是为什么啊？

老师的第一个代码中 字符输入缓冲流 
是不是缓冲整体的输入流，不仅是InputStreamReader还有
FileInputStream的类似于read这样的读取方法，对吧

字节到字符转换流InputStreamReader 使用的
是read（）方法去读取字节输入流数据，
 是一个一个字节输入，并转换成字符。
 我想问的是，
 这样的话，转换流效率是不是整个输入流中最拖累时间
 的？
 有没有方法可以给转换流增加缓冲区

老师这句不是在服务端中发送消息的线程中嘛  就算是发送消息也是 服务端发送给谁谁谁呀  为什么说是 公共数据区发送给客户端

linkedlist为什么线程不安全？

老师，怎么我不能拷贝进来

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class ChatRoomServer {

   //定义公共数据区
   public static String buf;
   public static void main(String[] args) {
       System.out.println("Chat  Server Version 1.0");
       System.out.println("Listen at 8888");
       try (ServerSocket ss = new ServerSocket(8888)) {

           while(true){
               Socket socket = ss.accept();
               System.out.println("连接到 "+socket.getInetAddress());
               new ChatReceive(socket).start();
               new ChatSend(socket).start();
           }
       } catch (IOException e) {
           throw new RuntimeException(e);
       }



   }
}

class ChatReceive extends Thread{
   private Socket socket;
   public ChatReceive(Socket socket){
       this.socket = socket;
   }

   @Override
   public void run() {
          doChatReceive();
   }



   public  void doChatReceive(){
        try(BufferedReader bf = new BufferedReader(new InputStreamReader(socket.getInputStream()))){
            while(true){
                String str = bf.readLine();
                synchronized ("abc"){
                    ChatRoomServer.buf = "["+socket.getInetAddress()+"]"+ str;
                    "abc".notifyAll();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
   }
}

class ChatSend extends Thread{
   private Socket socket;
   public ChatSend (Socket socket){
       this.socket = socket;
   }

   @Override
   public void run() {
       sendMsg();
   }
   private  void sendMsg() {
        try(PrintWriter pw = new PrintWriter(socket.getOutputStream())){
            while (true) {
                synchronized ("abc "){
                  //先让发送消息的线程处于等待状态
                    "abc".wait();
                    //将公共数据区中的消息发送给客户端
                    pw.println(ChatRoomServer.buf);
                    pw.flush();

                }

            }
        }catch (Exception e){
            e.printStackTrace();
        }
   }
}

老师想问一下连接后客户端一直循环输出null是什么问题呢？

老师我发现问题了，就是数据域里面的镜子和口红对象只能设置成静态的，为什么设置为私有的就没有死锁呢

class LipStick {
    private String LName;

    public LipStick(String LName) {
        this.LName = LName;
    }
}
class Mirror{
    private String MName;
    public Mirror(String MName){
        this.MName = MName;
    }
}
class Makeup extends Thread{
    private Mirror mirror = new Mirror("m1");
    private LipStick lipStick = new LipStick("l1");
    private String girlName;
    private int flag;//0代表口红，1代表镜子

    public Makeup(int flag,String girlName){
        this.flag = flag;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        this.doMakeup();
    }
    public void doMakeup(){
        if(flag==0){
            synchronized (lipStick){
                System.out.println(this.girlName+" 拿着口红");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){
                    System.out.println(this.girlName+" 拿着镜子");
                }
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+" 拿着镜子");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipStick){
                    System.out.println(this.girlName+" 拿着口红");
                }
            }
        }
    }
}



public class TestDeadThread {
    public static void main(String[] args) {
        Thread T1 = new Thread(new Makeup(0,"1"));
        Thread T2 = new Thread(new Makeup(1,"2"));
        T1.start();
        T2.start();

    }
}

老师想问问为什么没有死锁呢

字，节，与，字，符，的，区，别？

在缓冲区内，为什么不能使用字符串对象锁，或者是xx.class对象锁

一个是实现共享同一个字符串对象锁，不应该是共享同一个缓冲区资源吗

class对象锁对于生产者和消费者都使用了缓冲区对象，为什么实现不了

this是最符合这个模式的，使用this,就是意味着多个线程去争取一个资源时可实现同步，自定义对象的话，在两个线程中，可以先拿到缓冲区对象，在run方法实现同步

对于字符串对象锁和class对象锁，我不是很明白，请老师帮我解答一下

老师想问一下为什么会这样

主机名称跟IP地址一样？

为什么要修改host文件内容（把“127.0.0.1   activate.navicat.com”改成“上条视频获取的百度的IP   www.baidu.com“？）

意思是本视频获取的也只能是在自己电脑里预先设定好的值？

//for循环删除
for (int i=0;i<list.size();i++){
    list.remove(i);
}

//迭代器删除
for(Iterator<String> it = list.iterator();it.hasNext();){
    it.next();
    it.remove();
}

问题：使用迭代器删除元素时，iterator.remove()方法执行过程中，list数组是没有做动态变化的吧?

在list.remove()执行过程中list数组有做动态变化，所以出现在for循环中调用list.remove()删除全部元素时，无法删除干净的情况。

如果使用迭代器删除元素时，list数组动态变化了，而游标的位置又不变，那么也会出现无法删除干净的情况。

老师，您好。想问一下再main方法中哪里调用了compareTo方法，为什么添加进去就排好序了