DrawMoneyThread {
    (String[] args) {
        Account account = Account()DrawThread(account).start()DrawThread(account).start()}

}

DrawThread Thread{

    Account (String nameAccount accountdrawMoney) {
        (name).= account.= drawMoney}

    () {
        (..getBalance() >= .){
            System..println(.getName() + + .){
                Thread.()} (InterruptedException e) {
                e.printStackTrace()}
            ..setBalance(..getBalance() - .)System..println(+ ..getBalance())}{
            System..println(.getName() + )}
    }
}

Account {
    String () {
    }

    (String accountNobalance) {
        .= accountNo.= balance}

    String () {
        }

    (String accountNo) {
        .= accountNo}

    () {
        }

    (balance) {
        .= balance}

老师我的运行结果为什么是这样的，我的代码和老师的一样。

老师为甚么我的运行结果是这样的

我的代码和老师的一样

怎么还有 f 呢

请问老师,是否是因为字符串在常量池中创建后找得都是常量池这个对象的地址,我自己试了下如果对象锁不是同一个常量值那么还是会并行的

老师,请问下这样写的话比较麻烦吗

package com.bjsxt.线程同步;


public class TestSyncThread {
    public static void main(String[] args) {
        Program p = new Program();
        p.setName("Mokura");
        Thread thread = new Thread(new Working(p));
        Thread thread1 = new Thread(new Bought(p));
        thread.start();
        thread1.start();
        System.out.println("主线程结束");
    }
}
class Program {
    String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Program{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Working implements Runnable{
    private Program program;

    public Working(Program p) {
        this.program = p;
    }

    @Override
    public void run() {
        synchronized (this.program){
        try {
            System.out.println(program.getName() + "先去找工作");
            Thread.sleep(1000);
            System.out.println(program.getName() + "辛苦工作一个月");
            Thread.sleep(1000);
            System.out.println(program.getName() + "发工资啦!!!!");
            Thread.sleep(1000);
        }catch (Exception e){e.printStackTrace();}
    }
    }
}
class Bought implements Runnable{
    private Program program;

    public Bought(Program p) {
        this.program = p;
    }
    @Override
    public void run() {
        synchronized (this.program){
        try {
            System.out.println(this.program.getName()+"去超市转了");
            Thread.sleep(1000);
            System.out.println(this.program.getName()+"看中了2022-Bilibili春节限定花嫁手办");
            Thread.sleep(1000);
            System.out.println("心满意足的回家了");
        }catch (Exception e){e.printStackTrace();}
        }
    }
}

老师，通过字节流转成字符流然后用处理流包装添加行号的方式和直接用字符流然后用处理流包装添加行号，这两者而言，是不是后者的效率更高呀？

老师，这里写的时候应该是写的int类型的，为什么写出来是字符呢？我打开jdk上面是这样写的，意思是会实现int转String吗？

这样就可以解决了

老师，一个汉字占两个字节，为什么我文本里面写汉字，read出来的int个数是汉字数的三倍？

老师，请问为什么上面的BufferedOutputStream将OutputStream包装了，后面PrintStream又将这个OutputStream单独包装了一次？再就是我打开BufferedOutputStream的底层源码，里面有部分方法含有sychronized关键字，是不是跟StringBuffer一样是线程安全，这样导致效率不太高，然后进行了重新包装？然后为什么又有的方法没有sychronized关键字呢？

老师，什么时候需要用到remove方法，什么时候不需要用到呀？我看在讲解的时候，两次循环都没有用到

这个位置应该不是TREEIFY_THRESHOIL每循环-1吧，我理解的是：每循环binCount+1，然后如果这个数字达到7加上链表首位，达到8，再去判断是否变树节点，是不是老师口误了？还是我理解错了？

请问老师,学生这样理解做的对不对

请问老师,学生这样理解做的对不对

老师这样理解对吗