老师，

menuItemValidate

是什么意思

BasicSocketClient {
    (String[] args) {
        (Socket socket =Socket(,);
            BufferedWriter bw = BufferedWriter(OutputStreamWriter(socket.getOutputStream()));
            bw.write();
            bw.newLine();
            bw.flush();
        }(Exception e){
            .printStackTrace();
        }
    }
}

老师这样子为什么不可以

为啥我的结果是负的呢？多次执行也都是负的

package com.itbaizhan;

class SetName1 extends Thread{
//    public SetName1(String name) {
//        super(name);
//    }

    @Override
    public void run() {
        System.out.println(this.getName());
    }
}


public class TestSetNameThread {
    public static void main(String[] args) {
        SetName1 setName1 = new SetName1();
        setName1.setName("one1");
        setName1.start();
    }
}

SetName01类直接继承了Thread类

为什么不直接使用Thread类的setName方法啊？

反而要去用构造器构造名字

怎么在一行语句里，捕获多种异常呢

老师，你这个中文版的API有链接吗？

while(true){ String msg=br.readLine(); synchronized("abc"){ //把读取到的数据写入公共数据区 ChatRoomServer.buf="["+this.socket.getInetAddress()+"]:"+msg; //唤醒发送消息的线程对象。 "abc".notifyAll(); } } while(true){ synchronized("abc"){ //把读取到的数据写入公共数据区 ChatRoomServer.buf="["+this.socket.getInetAddress()+"]:"+br.readLine(); //唤醒发送消息的线程对象。 "abc".notifyAll(); } }分析一下在实现一对多交流的过程中为什么前面的代码可以实现功能，而后面那段代码会进入阻塞class ChatSend extends Thread{
    private Socket socket;
    /**创建发送数据线程*/
    /**
     * 向客户端发送消息的线程类
     */
    public ChatSend(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }

    /**
     * 将公共数据区的消息发送给客户端
     */
    public 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();
        }
    }
}
/**
 * 接收客户端消息的线程类
 */
class ChatReceive extends Thread{
    private Socket socket;
    public ChatReceive(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
            this.receiveMsg();
    }

    /**
     * 实现接收客户端发送的消息
     */
    public void receiveMsg(){
        try(BufferedReader br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
            while(true){
                String msg=br.readLine();
                synchronized("abc"){
                    //把读取到的数据写入公共数据区
                ChatRoomServer.buf="["+this.socket.getInetAddress()+"]:"+msg;
                    //唤醒发送消息的线程对象。
                "abc".notifyAll();
            }
            }

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
//定义公共数据区
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 serverSocket=new ServerSocket(8888)){
            while(true){

                Socket socket=serverSocket.accept();
                System.out.println("连接到： "+socket.getInetAddress());
                new ChatReceive(socket).start();
                new ChatSend(socket).start();

            }

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

老师，为什么我一开始用的后面那段代码运行后是陷入阻塞的，用了课上老师的前面那段代码就好了，我个人感觉br.readLine()放在哪里好像没什么影响，就不是很理解为什么会陷入阻塞

不是，这是干嘛啊

老师，这个temp不是fis.read()当前读到的那个字节的字节的数值吗，为什么能表示长度，不是很理解

A Runnable{

    () {
        (i=i<i++){
            System..println(Thread.().getName()++i){
            Thread.()} (InterruptedException e) {
            e.printStackTrace()}
        }

    }
}
B Runnable{

    () {
        (i=i<i++){
            System..println(Thread.().getName()++i){
                Thread.()} (InterruptedException e) {
                e.printStackTrace()}
        }
    }
}

TestJoinThread {
    (String[] args) {
        Thread t=Thread(A())Thread t1=Thread(B())t.start()t1.start()(i=i<i++){
            System..println(Thread.().getName()++i)(i==){
                {
                    t.join()} (InterruptedException e) {
                    e.printStackTrace()}
            }
            {
                Thread.()} (InterruptedException e) {
                e.printStackTrace()}
        }
    }
}

老师 我这个为什么是执行完子线程后才执行主线程 没有主线程和子线程一起执行啊？

老师，为什么声明数组用int出了这个地址（我也忘了这是啥了，老师/_ \），用Integer后就好了，这个是和那个泛型类制定具体数据类型一样的吗，什么原因导致的(;´༎ຶД༎ຶ`)

import java.io.IOException;

public class TestStopThread implements Runnable{

    private boolean flag=true;

    @Override

    public void run() {

        System.out.println(Thread.currentThread().getName()+"线程开始");

        int i=0;

        while (flag){

            System.out.println(Thread.currentThread().getName()+""+i++);

            try {

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName()+"线程结束");

        }

    }

    public void stop(){

        this.flag=flag;

    }

    public static void main(String[] args) throws IOException {

        System.out.println("主线程开始");

        TestStopThread tst=new TestStopThread();

        Thread t=new Thread(tst);

        t.start();

        System.in.read();

        tst.stop();

        System.out.println("主线程结束");

    }

}

老师 运行输入后 主线程结束 子线程还一直在跑 不能结束？

老师，假设notifyall唤醒了三个发送线程（称之为线程1,2,3），但此时又来了一个接收消息线程（线程4）想要修改共享缓冲区中的字符串，那么此时是4个线程同时争抢“abc”锁，会不会出现这样的执行顺序：线程1，线程2，线程4，线程3，这样的话就导致线程1，线程2发送是没问题的，但是线程3发送的消息已经是更改后的消息，而并非最开始的消息。

老师为什么用entry无法使用getkey方法

老师，问一下为什么我的idea里没有强制进入那些红色按钮啊，是要自己设置吗