老师，守护线程是在哪个线程里面被设置，就随那个线程结束嘛？

使用缓冲流的读写效率是不是自己定义缓冲区要低?

读写同一张图片，不用缓冲区是1746ms，1024长度的缓冲区用时3ms，预定文件长度的缓冲区用时2ms，缓冲流用时20ms。

老师，我这边已经定义了o==null,return false;可是打印出来还是true

package com.bjsxt;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class y123 {


    public static void main(String[] args) {
            Person p1 = new Person();
            Person p2 = new Person();
            System.out.println(p1.equals(p2));
            String s1 = new String("尚学堂");
            String s2 = new String("尚学堂");
            System.out.println(s1==s2);
            System.out.println(s1.equals(s2));
        }
    }
class Person {
    int id;
    String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Person() {
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        } else {
            if (o instanceof Person) {
                Person c = (Person) o;
                if (c.id == this.id) {
                    return true;
                }
            }
        }
        return false;
    }
}

老师，这里对用户姓名验证的变量和验证菜单项的变量重名了都是input，不会导致错误吗，这种写法是不是要尽量避开

/**
 * 死锁
 * 解决死锁问题
 */

/**
 * 口红类
 */
class Lipstick{

}

/**
 * 镜子类
 */
class Mirror{

}

/**
 * 化妆线程类
 */
class Makeup extends Thread{
    private int flag;//如果flag=0，拿着口红；否则，拿着镜子
    private String girlName;
    static Lipstick lipstick =new Lipstick() ;
    static Mirror mirror =new Mirror() ;
    public Makeup(int flag,String girlName){
        this.flag=flag;
        this.girlName=girlName;
    }
    @Override
    public void run() {
       this.doMakeup() ;
    }

    /**
     * 开始化妆
     */
    public void doMakeup(){
        if(this.flag==0){
            synchronized(lipstick ){
                System.out.println(this.girlName+"拿着口红");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                }
                synchronized(mirror){
                    System.out.println(this.girlName+"拿着镜子");
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+"拿着镜子");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                }
                synchronized (lipstick ){
                    System.out.println(this.girlName+"拿着口红");
            }
        }
    }
}

public class DeadLockThread {
    public static void main(String[] args) {
        new Makeup(0,"小丫").start();
        new Makeup(0,"大丫").start();
    }
}

import java.io.*;

public class TestLineNumber2 {
    public static void main(String[] args) {
        try(BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/liuxuan1.txt")))){
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:/liuxuan4.txt")));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;

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

        }
    }
}

代码实现了文本的创建，但是文本里没后数据

关于如下部分

我不懂为什么是 ！= null 的时候才关闭，如果等于null了，说明出现读或者写有错误，

那么在catch(Exception e) 内，print后，不应该也要关闭出现异常的的部分？

package com.bjsxt.thread;

/**
 * 使用this作为对象锁
 * 使用字符串作为对象锁
 * 使用class对象作为对象锁
 */
/**
 * 定义销售员工类
 */
class Sale{
    private String name;
    public Sale(String name){
        this.name = name;
    }
    public void  money(){
        synchronized ("s") {
            try {
                System.out.println(this.name +
                        " 被领导表扬");
                Thread.sleep(500);
                System.out.println(this.name +
                        " 拿钱");
                Thread.sleep(500);
                System.out.println(this.name +
                        " 对公司表示感谢");
                Thread.sleep(500);
                System.out.println(this.name +
                        " 开开心心的拿钱走人");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Programmer{
    private String name;
    public Programmer(String name){
        this.name = name;
    }
    /**
     * 打开电脑
     */
    public void computer(){
        synchronized (this) {
            try {
                System.out.println(this.name + " 接通电源");
                Thread.sleep(500);
                System.out.println(this.name + " 按开机按键");
                Thread.sleep(500);
                System.out.println(this.name + " 系统启动中");
                Thread.sleep(500);
                System.out.println(this.name + " 系统启动成功");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 编码
     */
    public void  coding(){
        synchronized (this){
            try {
                System.out.println(this.name + " 双击 Idea");
                Thread.sleep(500);
                System.out.println(this.name + " Idea 启动完毕");
                Thread.sleep(500);
                System.out.println(this.name + " 开开心心的写代码");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 去卫生间
     */
    public void wc(){
        synchronized ("wc") {
            try {
                System.out.println(this.name + " 打开卫生间门");
                Thread.sleep(500);
                System.out.println(this.name + " 开始排泄");
                Thread.sleep(500);
                System.out.println(this.name + " 冲水");
                Thread.sleep(500);
                System.out.println(this.name + " 离开卫生间");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 领取奖金
     */
    public void money(){
        synchronized ("p") {
            try {
                System.out.println(this.name + " 被领导表扬");
                Thread.sleep(500);
                System.out.println(this.name + " 拿钱");
                Thread.sleep(500);
                System.out.println(this.name + " 对公司表示感谢");
                Thread.sleep(500);
                System.out.println(this.name + " 开开心心的拿钱走人");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 打开电脑的工作线程
 */
class Working1 extends Thread{
    private Programmer p;
    public Working1(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.computer();
    }
}

/**
 * 编写代码的工作线程
 */
class Working2 extends Thread{
    private Programmer p;
    public Working2(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.coding();
    }
}

/**
 * 去厕所的线程
 */
class Wc extends Thread{
    private Programmer p;
    public Wc(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.wc();
    }
}
/**
 * 销售部领取奖金的线程
 */
class SaleMoney extends Thread{
    private Sale s;
    public SaleMoney(Sale s){
        this.s = s;
    }
    @Override
    public void run() {
        this.s.money();
    }
}
/**
 * 程序员领取奖金的线程
 */
class ProgrammerMoney extends Thread{
    private Programmer p;
    public ProgrammerMoney(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.money();
    }
}
public class ObjectLock {
    public static void main(String[] args) {
        /*Programmer zs = new Programmer("张三");
        new Working1(zs).start();
        new Working2(zs).start();*/
        /*Programmer zs = new Programmer("张三");
        Programmer ls = new Programmer("李四");
        Programmer wu = new Programmer("王五");
        new Wc(zs).start();
        new Wc(ls).start();
        new Wc(wu).start();*/
        Programmer ls = new Programmer("李四");
        Programmer wu = new Programmer("王五");
        Sale s1 = new Sale("王丽丽");
        Sale s2 = new Sale("王莉莉");
        //new ProgrammerMoney(ls).start();
        //new ProgrammerMoney(wu).start();
        new SaleMoney(s1).start();
        new SaleMoney(s2).start();
    }
}

老师，用字符串作为对象锁也可以实现各自部门的人去各自部门串行领取奖金，达到和使用class对象作为锁一样的效果。都是可以对多个线程操作多个对象进行同步。前面同学问的问题我看了，字符串可以是不同类，Class只能是同一个类。所以意思各有各的应用场景，但是有时候也能达到一样的效果。

老师，这是我总结的您看一下

this：多个线程操作同一个对象可以实现同步效果

字符串：所有线程操作到具有synchrunized(字符串)的就会实现同步效果

class对象：当多个线程操作到通过同一个类实例化的对象的时候会实现同步效果

老师，wait() 和 notify() 为什么是交叉唤醒的，在馒头的存放中调用了wait() 和 notify() ，代码运行，notify() 为什么唤醒的不是馒头存放的wait() 方法，而是取出馒头的wait() 方法。

&&老师这个符号逻辑运算符不是短路与，在这里用是什么意思

咋启动了，需要手动启动MySQL?就安装完了，就没了

老师我还是不理解为什么要用线程同步，如果已经放满了，push方法发while不是会一直循环，防止再次放入，如果已经取空了，pop的while也会一直循环，直到另一个线程修改index的时候会跳出自己的while循环，不是吗

我想到的只能是缓冲区空的时候，取线程一直while，然后直到存线程放入后，但是还没来得及修改index，就切换到取线程，此时index没有变化，实际有馒头了，但是等下次轮询index就会更新，这也只是减慢了效率，不会影响取线程异常，我想不到其他异常情况了

求老师点拨一下

老师，在调用第11次add的时候，空间是10+5还是10+15？

老师说192.168.31.113是ip地址指本机

那上边那个127.0.0.1是啥 也说指本机

你好，老师这一章节的提取码显示不正确，能发一个正确的吗？