有效沟通问答-【官方】百战程序员_IT在线教育培训机构

/**
 * 账户类
 */
class Account1{
    // 账户
    private String account1;

    // 账户余额
    private double balance;

    public Account1() {
    }

    public Account1(String account1, double balance) {
        this.account1 = account1;
        this.balance = balance;
    }

    public String getAccount1() {
        return account1;
    }

    public void setAccount1(String account1) {
        this.account1 = account1;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

/**
 * 取款线程
 */
class DrawThread1 extends Thread{

    // 账户对象
    private Account1 account1;

    // 取款金额
    private double drawMoney;
    
    public DrawThread1(String name,Account1 account1,double drawMoney){
        super(name);
        this.account1 = account1;
        this.drawMoney = drawMoney;
    }
    /**
     * 取款线程的线程体
     */
    @Override
    public void run() {
        // 使用synchronized块实现线程同步
        synchronized (this.account1) { // 当前账户对象作为线程锁
            if(this.account1.getBalance() >= this.drawMoney){
                System.out.println("取款成功，吐出钞票:"+this.drawMoney);
                try {
                    Thread.sleep(1000); // 线程休眠1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 更新账户余额
                this.account1.setBalance(this.account1.getBalance() - this.drawMoney);
                System.out.println("账户余额："+this.account1.getBalance());
            } else {
                System.out.println("取款失败，账户余额不足");
            }
        }
    }
}
/**
 * 取款
 */
public class DrawMoneyThread2 {

    public static void main(String[] args) {

        // 实例化账户对象
        Account1 account1 = new Account1("1234",1000);

        // 启动线程
        new DrawThread1("老公",account1,800).start();
        new DrawThread1("老婆",account1,800).start();

    }
}

为什么线程名没有设置成功？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1606楼

老师我想问一下：工作当中是继承Thread类用的多一点，还是实现Runnable接口用的多一点。

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1607楼

老师，请问这些容器存元素的时候，除了一个一个put/add进去，还可以怎么操作？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/容器（旧） 1608楼

package G_Multithreading.E_Synchronized;

//面包类
class Bread{
    private int id;
    public Bread(int id){
        this.id = id;
    }
}

//缓冲区
class SynBuffer{
    //存放面包的盒子
    private Bread[] breads = new Bread[10];
    //存放面包盒子的索引
    private int index;
    //放面包
    public synchronized void push(Bread bread){
        //判断盒子是否存满
        while (breads.length == this.index + 1){
            try {
                /*
                语法：wait(),该方法必须要在synchronized块中调用。
                     wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
                     其他需要该对象锁的线程就可以继续运行了。
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /*
            语法：该方法必须要在synchronized块中调用。
                 该方法会唤醒处于相同对象的，并且等待状态队列中的一个线程。
             */
            //提醒取面包
            this.notify();
            breads[this.index] = bread;
            this.index++;
        }
    }
    //取走面包
    public synchronized Bread pop(){
        while (breads.length == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return breads[this.index];
    }
}

//生产面包线程
class Produce extends Thread{
    SynBuffer synBuffer;
    public Produce(SynBuffer synBuffer){
        this.synBuffer = synBuffer;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            Bread bread = new Bread(i);
            this.synBuffer.push(bread);
            System.out.println("生产面包" + i);
        }
    }
}

//消费者线程
class Customer extends Thread{
    SynBuffer synBuffer;
    public Customer(SynBuffer synBuffer){
        this.synBuffer = synBuffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            Bread bread = this.synBuffer.pop();
            System.out.println("取走面包" + i);
        }
    }
}
public class SynchronizedBuffer {
    public static void main(String[] args) {
        SynBuffer synBuffer = new SynBuffer();
        new Produce(synBuffer).start();
        new Customer(synBuffer).start();
    }
}

老师，他到取出的是够就高速index是-1，哪里出错了？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1609楼

老师，这个运行不成功是怎么回事

package com.xin.test;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class TestCalendar {
    public static void main(String[] args) {
        //得到相关日期元素
        GregorianCalendar calendar = new GregorianCalendar(2999, 10, 9, 22, 10, 50);
        int year = calendar.get(Calendar.YEAR);//打印：2999
        int month = calendar.get(Calendar.MONTH);//打印：10
        int day = calendar.get(Calendar.DAY_OF_MONTH);//打印：9
        int day2 = calendar.get(Calendar.DATE);//打印：9
        //日：Calender.DATE和Calender.DAY_OF_MONTH同义
        int date = calendar.get(Calendar.DAY_OF_WEEK);//打印3
        //星期几这里是：周日是1，周一是2，。。。周六是7
        System.out.println(year);
        System.out.println(month);

        System.out.println(day);
        System.out.println(day2);
        System.out.println(date);
        //设置日期
        GregorianCalendar calendar2 = new GregorianCalendar();
        calendar2.set(Calendar.YEAR, 2999);
        calendar2.set(Calendar.MONTH, Calendar.FEBRUARY);
        calendar2.set(Calendar.DATE, 3);
        calendar2.set(Calendar.HOUR_OF_DAY, 10);
        calendar2.set(Calendar.MINUTE, 20);
        calendar2.set(Calendar.SECOND, 23);
        printCalendar(calendar2);
        //日期计算
        GregorianCalendar calendar3 = new GregorianCalendar(2999, 10, 9, 22, 10, 50);
        calendar3.add(Calendar.MONTH, -7);//月份减7
        calendar3.add(Calendar.DATE, 7);//增加7天
        printCalendar(calendar3);
        //日历对象和时间对象转化
        Date d = calendar3.getTime();
        GregorianCalendar calendar4 = new GregorianCalendar();
        calendar4.setTime(new Date());
    }

    static void printCalendar(Calendar calendar) {
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int date = calendar.get(Calendar.DAY_OF_WEEK) - 1;//星期几
        String week = "" + ((date == 0) ? "日" : date);
        int hour = calendar.get(Calendar.HOUR);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.printf("%d年%d月%d日,星期%s %d:%d:%d\n", year, month, week, day, hour, minute, second);
    }
}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/常用类 1610楼

package com.bjsxt;

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

}

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

}

/**
 * 化妆线程类
 */
class Makeup extends Thread{
    private int flag; //flag=0:拿着口红。flag!=0:拿着镜子
    private String girlName;
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    public void setFlag(int flag) {
        this.flag = flag;
    }

    public void setGirlName(String girlName) {
        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 DeadLockThread {
    public static void main(String[] args) {
        Makeup makeup = new Makeup();
        makeup.setFlag(0);
        makeup.setGirlName("大丫");
        Makeup makeup1 = new Makeup();
        makeup1.setFlag(1);
        makeup1.setGirlName("小丫");
        makeup.start();
        makeup1.start();
    }
}

两个线程都是同时执行，口红类被锁了当它要去用镜子时已经被else里的先占用了，还是死锁的状态啊？为什么可以执行呢？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1611楼

System.exit(0);
System.exit(1);

老师这两个有什么区别？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1612楼

问题：我的代码运行后，客户端向服务端发送消息后就会无限的输出”对方说：null，对着代码看过还是没找到原因，麻烦老师帮忙看看。
客户端运行情况：
代码

package com.wonderx.TCPDemo4;

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

/**
 * 点对点聊天的服务端
 */
public class ChatSocketServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(8888);
            System.out.println("服务器启动，等待监听端口8888。。。");
            Socket socket = serverSocket.accept();
            System.out.println("连接成功！！！");
            new Send(socket).start();
            new Receive(socket).start();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {

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

/*
发送消息的线程
 */
class Send extends Thread {
    private Socket socket;

    public Send(Socket socket) {
        this.socket = socket;
    }

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

    /*
    发送消息的方法
     */
    private void sendMsg() {
        Scanner scanner = null;
        PrintWriter pw = null;
        try {
            //创建Scanner对象
            scanner = new Scanner(System.in);
            //创建向客户端发送消息的流对象
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true) {
                String str = scanner.nextLine();
                pw.println(str);
                pw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (scanner != null) {
                scanner.close();
            }
            if (pw != null) {
                pw.close();
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/*
接受消息线程
 */
class Receive extends Thread {
    private Socket socket;

    public Receive(Socket socket) {
        this.socket = socket;
    }

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

    /*
    接收消息的方法
     */
    private void receiveMsg() {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            String str = br.readLine();
            System.out.println("对方说：" + str);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.wonderx.TCPDemo4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 点对点聊天的客户端
 */
public class ChatSocketClient {
    public static void main(String[] args) {
        Socket socket = null;
        try {
            System.out.println("连接中。。。");
            socket = new Socket("127.0.0.1", 8888);
            System.out.println("连接成功！！！");
            new ClientSend(socket).start();
            new ClientReceive(socket).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
发送消息的线程类
 */
class ClientSend extends Thread {
    private Socket socket;

    public ClientSend(Socket socket) {
        this.socket = socket;
    }

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

    /*
    发送消息的方法
     */
    private void sendMsg() {
        Scanner scanner = null;
        PrintWriter pw = null;
        try {
            //创建Scanner对象
            scanner = new Scanner(System.in);
            //创建向客户端发送消息的流对象
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true) {
                String str = scanner.nextLine();
                pw.println(str);
                pw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (scanner != null) {
                scanner.close();
            }
            if (pw != null) {
                pw.close();
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/*
接受消息的线程类
 */
class ClientReceive extends Thread {
    private Socket socket;

    public ClientReceive(Socket socket) {
        this.socket = socket;
    }

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

    /*
    接收消息的方法
     */
    private void receiveMsg() {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true) {
                String str = br.readLine();
                System.out.println("对方说：" + str);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 1613楼

老师如果不清楚文件里是什么数据应该怎么读？

int[] arr = new int[]{10,20,30,40,50,60,70,80,90,100};
for(int i = 0;i<arr.length;i++){
    raf.writeInt(arr[i]);
}
raf.seek(4); 
System.out.println(raf.read());

我这样直接调用read()返回的是0

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 1614楼

老师，能不能总结下，线程里

this作为对象锁，字符串作为对象锁，Class作为对象锁

这三种的区别啊，有点晕。

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1615楼

;
;

{
    ([] args) {
        fis=;
        {
            fis=FileInputStream();
            =StringBuilder();
            temp=;
            ((temp=fis.read())!=-){
                ..println(temp);
                .append(()temp);
            }
            ..println(.toString());
        } (e) {
            e.printStackTrace();
        }{
            {
                (fis!=){
                    fis.close();
                }
            } (e) {
                e.printStackTrace();
            }
        }
    }
}

为什么我运行之后是

abc

多了13和10啊？我D盘只打了abc三个字母，这个13和10不知道是怎么出来的

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 1616楼

1---老师,那个String对象的synchronized锁的对象是哪个，那个代码块里的对象？

2---还是说只要是相同String对象加锁的代码块就会变成一个顺序执行的队列？不关乎里面的对象？

3---还是说只要是被String对象加锁了，在这个代码块里面的对象，在外部的没有加synchronized锁的方法里也不允许使用？

老师，麻烦回答的仔细点，有点懵圈。

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 1617楼

想问一下这里为何是23小时而不是24小时？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/常用类 1618楼

老师，PrintWriter要传入true才会自动刷新，带我这写就会报错

PrintWriter pw2 = new PrintWriter("d:aa.txt",true);

把true改为字符串形式就不会

PrintWriter pw2 = new PrintWriter("d:aa.txt","true");

所以我想调用它的自动刷新功能应该怎么写？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 1619楼

线程是否需要手动关闭，不需要它是如何处理的

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 1620楼

同学您好