public static void main(String[] args) throws IOException, InterruptedException { ServerSocket serverSocket = new ServerSocket(10086); System.out.println("准备接受信号"); Socket accept = serverSocket.accept(); System.out.println("接收到"+accept.getRemoteSocketAddress()+"的信号"); InputStream inputStream = accept.getInputStream(); BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream); byte []brr=new byte[1024*1088]; int read; int sum=0; File file = new File("net-app\\src\\com\\itheima\\d10brother\\ly.mp4"); BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(file)); while ((read=bufferedInputStream.read())!=-1){ System.out.println(Thread.currentThread().getName()+"正在读取中"); Thread.sleep(500); sum+=read; System.out.println(Thread.currentThread().getName()+"已经读取到"+sum+"字节"); bufferedOutputStream.write(brr,0,read); System.out.println(Thread.currentThread().getName()+"正在通过socket发送中，已发送"+sum+"字节"); } bufferedInputStream.close(); bufferedOutputStream.close(); System.out.println("复制完成"); }

这段代码是一个Java程序，作用是从一个Socket连接中读取数据，并将读取的数据写入到一个本地文件中。具体流程如下：

1. 创建一个ServerSocket对象，指定端口号为10086，用于监听客户端的连接请求。

2. 调用ServerSocket的accept()方法，等待客户端连接，一旦接收到连接请求，就返回一个Socket对象，用于和客户端进行通信。

3. 获取Socket对象的输入流，使用BufferedInputStream进行包装，方便读取数据。

4. 创建一个byte数组，用于缓存读取的数据。

5. 创建一个File对象，指定本地文件路径，用于存储读取的数据。

6. 创建一个BufferedOutputStream对象，用于将读取的数据写入到本地文件中。

7. 使用while循环从输入流中读取数据，每次读取一定数量的数据，并将读取的数据写入到本地文件中。

8. 循环结束后，关闭输入流和输出流，输出复制完成的消息。

需要注意的是，在while循环中，读取数据的操作使用的是read()方法，这个方法每次只会读取一个字节，因此在写入数据的时候，需要将读取的字节数组的长度作为第三个参数传递给write()方法。同时，为了模拟复制文件的过程，代码中使用了Thread.sleep()方法来让程序暂停一段时间。

相关问题

1.分别运用Runnable和Callable接口实现线程 2.分别运用同步代码段、同步方法和同步锁的方法实现线程同步 3.实验UDP协议实现用户信息的发送和接受功能 4.运用TCP协议实现向服务器上传文件

1. 运用Runnable和Callable接口实现线程

Runnable接口和Callable接口都可以用来实现线程，但是Callable接口可以返回执行结果，而Runnable接口不能。下面分别给出两种方式的示例代码：

（1）使用Runnable接口实现线程

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("线程开始执行");
    }
}

// 在主函数中创建线程并启动
public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.start();
}

（2）使用Callable接口实现线程

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 线程执行的代码
        return "线程执行完毕";
    }
}

// 在主函数中创建线程并启动
public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Future<String> future = executorService.submit(new MyCallable());
    String result = future.get();
    System.out.println(result);
    executorService.shutdown();
}

2. 分别运用同步代码段、同步方法和同步锁的方法实现线程同步

Java中的线程同步可以通过synchronized关键字来实现，有三种方式：同步代码段、同步方法和同步锁。下面分别介绍这三种方式的实现方法。

（1）同步代码段

public class MyRunnable implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        synchronized (this) { // 使用this作为锁对象
            for (int i = 0; i < 5; i++) {
                count++; // 非原子操作
                System.out.println(Thread.currentThread().getName() + " count=" + count);
            }
        }
    }
}

（2）同步方法

public class MyRunnable implements Runnable {
    private int count = 0;

    @Override
    public synchronized void run() { // 使用synchronized修饰方法
        for (int i = 0; i < 5; i++) {
            count++; // 非原子操作
            System.out.println(Thread.currentThread().getName() + " count=" + count);
        }
    }
}

（3）同步锁

public class MyRunnable implements Runnable {
    private int count = 0;
    private final Object lock = new Object(); // 定义一个锁对象

    @Override
    public void run() {
        synchronized (lock) { // 使用lock作为锁对象
            for (int i = 0; i < 5; i++) {
                count++; // 非原子操作
                System.out.println(Thread.currentThread().getName() + " count=" + count);
            }
        }
    }
}

3. 实验UDP协议实现用户信息的发送和接受功能

UDP协议是一种无连接的协议，它不保证数据传输的可靠性、顺序性和唯一性。下面给出发送和接收用户信息的示例代码：

（1）发送用户信息

public class UDPSender {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket();
        String message = "Hello, World!";
        byte[] data = message.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 8888;
        DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
        socket.send(packet);
        socket.close();
    }
}

（2）接收用户信息

public class UDPReceiver {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8888);
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        socket.receive(packet);
        String message = new String(packet.getData(), 0, packet.getLength());
        System.out.println("Received message: " + message);
        socket.close();
    }
}

4. 运用TCP协议实现向服务器上传文件

TCP协议是一种面向连接的协议，它保证数据传输的可靠性、顺序性和唯一性。下面给出向服务器上传文件的示例代码：

public class TCPClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8888);
        OutputStream outputStream = socket.getOutputStream();
        FileInputStream fileInputStream = new FileInputStream("D:\\test.txt");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fileInputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, len);
        }
        fileInputStream.close();
        outputStream.close();
        socket.close();
    }
}

public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\test_copy.txt");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            fileOutputStream.write(buffer, 0, len);
        }
        fileOutputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

JAVA 如何根据IP获取其他机器的CPU、内存、 磁盘状态等信息

要获取其他机器的CPU、内存、磁盘状态等信息，需要借助Java的Socket编程实现远程获取目标机器的系统状态信息。可以通过在目标机器上运行一个服务端程序，然后在本地机器上运行一个客户端程序来实现远程获取目标机器的系统状态信息。

以下是一个简单的示例代码：

服务端代码：

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端已启动，等待客户端连接...");

        while (true) {
            Socket socket = serverSocket.accept();
            System.out.println("客户端已连接：" + socket.getInetAddress());

            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
            String ip = (String) objectInputStream.readObject();

            // 获取目标机器的系统状态信息
            SystemInfo systemInfo = new SystemInfo(ip);
            System.out.println(systemInfo.getCpuUsage());
            System.out.println(systemInfo.getMemoryUsage());
            System.out.println(systemInfo.getDiskUsage());

            socket.close();
        }
    }
}

客户端代码：

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {
    public static void main(String[] args) throws UnknownHostException, IOException {
        String ip = "192.168.1.100"; // 目标机器的IP地址

        Socket socket = new Socket(ip, 9999);
        System.out.println("已连接服务端：" + socket.getInetAddress());

        ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
        objectOutputStream.writeObject(ip);

        socket.close();
    }
}

其中，SystemInfo类用于获取目标机器的系统状态信息，示例代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SystemInfo {
    private String ip;

    public SystemInfo(String ip) {
        this.ip = ip;
    }

    public String getCpuUsage() throws IOException, InterruptedException {
        Process process = Runtime.getRuntime().exec("ssh " + ip + " top -bn1 | grep %Cpu | awk '{print $2}'");
        process.waitFor();

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line = reader.readLine();
        return "CPU使用率：" + line;
    }

    public String getMemoryUsage() throws IOException, InterruptedException {
        Process process = Runtime.getRuntime().exec("ssh " + ip + " free -m | awk 'NR==2{printf(\"%s/%sMB %.2f%%\", $3,$2,$3*100/$2 )}'");
        process.waitFor();

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line = reader.readLine();
        return "内存使用情况：" + line;
    }

    public String getDiskUsage() throws IOException, InterruptedException {
        Process process = Runtime.getRuntime().exec("ssh " + ip + " df -hl | awk '/^\\/dev/{printf(\"%s/%s (%s)\", $3,$2,$5);exit}'");
        process.waitFor();

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line = reader.readLine();
        return "磁盘使用情况：" + line;
    }
}

注意：需要在本地机器和目标机器上安装ssh，并且在本地机器上配置ssh免密码登录目标机器，才能实现远程获取目标机器的系统状态信息。