精华内容
下载资源
问答
  • 利用java技术实现多线程文件传输
  • NULL 博文链接:https://logicluo.iteye.com/blog/2196661
  • 1.最近一个项目需要实现客户端文件上传到server,但是不希望把文件上传z

    1.最近一个项目需要实现客户端文件上传到server,但是不希望把文件上传在与服务器同一台机器上,所以只能通过socket编程实现。


    package socket;


    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;


    /**
     * <p>
     * Company: 
     * </p>
     * 
     * @author 
     * @date 2014年7月7日
     * @version 1.0
     */


    public class ServerTransfer {


    private int defaultBindPort = Constants.DEFAULT_BIND_PORT; // 默认监听端口号为10000
    private int tryBindTimes = 0; // 初始的绑定端口的次数设定为0


    private ServerSocket serverSocket; // 服务套接字等待对方的连接和文件发送


    private ExecutorService executorService; // 线程池
    private final int POOL_SIZE = 4; // 单个CPU的线程池大小


    /**
    * 不带参数的构造器,选用默认的端口号

    * @throws Exception
    */
    public ServerTransfer() throws Exception {
    try {
    this.bingToServerPort(defaultBindPort);
    executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
    .availableProcessors() * POOL_SIZE);
    System.out.println("开辟线程数 : "
    + Runtime.getRuntime().availableProcessors() * POOL_SIZE);
    } catch (Exception e) {
    throw new Exception("绑定端口不成功!");
    }
    }




    private void bingToServerPort(int port) throws Exception {
    try {
    serverSocket = new ServerSocket(port);
    System.out.println(port);
    System.out.println("服务启动!");
    } catch (Exception e) {
    this.tryBindTimes = this.tryBindTimes + 1;
    port = port + this.tryBindTimes;
    if (this.tryBindTimes >= 20) {
    throw new Exception("您已经尝试很多次了,但是仍无法绑定到指定的端口!请重新选择绑定的默认端口号");
    }
    // 递归绑定端口
    this.bingToServerPort(port);
    }
    }


    public void service() {
    Socket socket = null;
    while (true) {
    try {
    socket = serverSocket.accept();
    executorService.execute(new Handler(socket));
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    }


    public static void main(String[] args) throws Exception {
    new ServerTransfer().service();
    }
    }


    Headler 


    package socket;


    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.FileOutputStream;
    import java.net.Socket;
    import java.util.zip.GZIPOutputStream;


    /**
     * <p>
     * Company: 
     * </p>
     * 
     * @author 
     * @date 2014年7月7日
     * @version 1.0
     */


    class Handler implements Runnable {
    private Socket socket;


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


    public void run() {


    System.out.println("New connection accepted " + socket.getInetAddress()
    + ":" + socket.getPort());


    DataInputStream dis = null;
    DataOutputStream dos = null;


    int bufferSize = 8192;
    byte[] buf = new byte[bufferSize];


    try {
    dis = new DataInputStream(new BufferedInputStream(
    socket.getInputStream()));
    String savePath = Constants.RECEIVE_FILE_PATH + dis.readUTF();
    long length = dis.readLong();
    dos = new DataOutputStream(new BufferedOutputStream(
    new GZIPOutputStream(new FileOutputStream(savePath))));


    int read = 0;
    long passedlen = 0;
    while ((read = dis.read(buf)) != -1) {
    passedlen += read;
    dos.write(buf, 0, read);
    System.out.println("文件[" + savePath + "]已经接收: " + passedlen
    * 100L / length + "%");
    }
    System.out.println("文件: " + savePath + "接收完成!");


    } catch (Exception e) {
    e.printStackTrace();
    System.out.println("接收文件失败!");
    } finally {
    try {
    if (dos != null) {
    dos.close();
    }
    if (dis != null) {
    dis.close();
    }
    if (socket != null) {
    socket.close();
    }
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    }
    }


    ClientServer


    package socket;


    import java.io.BufferedInputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.zip.GZIPInputStream;


    /**
     * <p>
     * Company: 
     * </p>
     * 
     * @author 
     * @date 2014年7月7日
     * @version 1.0
     */


    public class ClientTransfer {


    // private String sendFilePath = Constants.SEND_FILE_PATH;
    //
    private String sendFilePath = "D:/test";




    public void service() {
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(sendFile("D:/test1/test.zip"));
    }




    private static Runnable sendFile(final String filePath) {
    return new Runnable() {


    private Socket socket = null;
    private String ip = "localhost";
    private int port = 10000;


    public void run() {
    System.out.println("开始发送文件:" + filePath);
    File file = new File("D:/test1/test.zip");
    if (createConnection()) {
    int bufferSize = 8192;
    byte[] buf = new byte[bufferSize];
    try {

    GZIPInputStream gzin = new GZIPInputStream(new FileInputStream(
        "D:\\test1\\test.zip"));
        java.io.InputStream is = new BufferedInputStream(gzin);
        DataInputStream fis = new DataInputStream(
        is);
       
    DataOutputStream dos = new DataOutputStream(
    socket.getOutputStream());


    dos.writeUTF(file.getName());
    dos.flush();
    dos.writeLong(file.length());
    dos.flush();


    int read = 0;
    int passedlen = 0;
    long length = file.length(); // 获得要发送文件的长度
    while ((read = fis.read(buf)) != -1) {
    passedlen += read;
    System.out.println("已经完成文件 [" + file.getName()
    + "]百分比: " + passedlen * 100L / length
    + "%");
    dos.write(buf, 0, read);

    }


    dos.flush();
    fis.close();
    dos.close();
    socket.close();
    System.out.println("文件 " + filePath + "传输完成!");
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    }


    private boolean createConnection() {
    try {
    socket = new Socket(ip, port);
    System.out.println("连接服务器成功!");
    return true;
    } catch (Exception e) {
    System.out.println("连接服务器失败!");
    return false;
    }
    }


    };
    }


    public static void main(String[] args) {
    new ClientTransfer().service();
    }
    }





    package socket;


    /**
     * <p>Company: </p>
     * @author 
     * @date 2014年7月7日
     * @version 1.0
     */


    public interface Constants {  
        
        public final static String RECEIVE_FILE_PATH = "D:\\target\\";  
          
        public final static String SEND_FILE_PATH = "D:\\send";  
          
        public final static int DEFAULT_BIND_PORT = 8888;  
    }  


     本文实现了GZIP文件的上传和下载,如果需要上传任何文件的内容,只需要更去除Handler 和ClientServer两个类中的 GZIPOutputStream 一层封装既可。


    其实ClientServer也可以实现多线程。


    展开全文
  • 面试题:如果使用Java开发多线程传输文件,你如何实现。(只需要说明技术和思路) BS结构 H5,文件组件标签,有多个属性,文件切割相关属性。把一个文件切割,从文件的第几个字节开始读取,读取多少字节。 服务端...

    面试题:如果使用Java开发多线程传输文件,你如何实现。(只需要说明技术和思路)

    BS结构

    H5,文件组件标签,有多个属性,文件切割相关属性。把一个文件切割,从文件的第几个字节开始读取,读取多少字节。

    服务端本身就是一个多线程,
    Commons-Fileupload

    一个进程有多个线程,一个线程有多个协程

    CS结构

    使用多线程技术和RandomAccessFile技术实现。
    多线程,提高效率使用ExecutorService线程池,优化代码。
    RandomAccessFile是随机文件读写流,打开文件,做随机读写。通过分隔文件,跳过不需要读写的字节数,进行读写操作。

    socket+IO
    java.io.RandomAccessFile 文件随机读写流

    上传:
    client:

     class ClientMain{
    	  public static void main(String[] args){
    	    Socket s = new Socket(ip, port);
    	    File file = new File(path);
    	    FileInputStream fis = new FileInputStream(file);
    	    // 文件的总体长度
    	    long length = fis.available();
                // 设置10线程上传。
    	    long point = length/10;
    	    // 让服务器创建文件
                OutputStream output = s.getOutputStream();
    	    output.write("{\"filename\"=\"xxx\"}".byteArray());
    	    // 阻塞等待,等待多线程上传结束。
    	    // 创建一个线程池,固定容量,只有10个线程。
                ExecutorService es = ExecutorServices.newFixedThreadPool(10);
    	    ArrayList fArray = new ArrayList();
    	    for(int i = 0; i < 10; i++){
    	      Socket upload = new Socket(ip, port);
    	      int index = (i * point);
    	      int endIndex = 0;
    	      if(i != 9){
    	        endIndex = (i + 1) * point;
    	      }else{
    	        endIndex = length;
    	      }
    	      Future<Object> f = 
    	        es.submit(new UpdateClient(file, index, endIndex, upload));
    	      fArray.add(f);
    	    }
    	    int flag = 10;
    	    while(flag > 0){
    	      for(Future f : fArray){
    	        try{
    		  f.get(10, TimeUnit.MILLSSECOND);
    		  flag--;
    		  fArray.remove(f);
    		}catch(Exception e){}
    	      }
    	    }
    	    // 所有的线程都执行结束了。文件上传结束。
    	    s.close();
    	  }
    	}
    	class UploadClient implements Callable{
    	  private File file; // 要上传的文件
    	  private int index; // 要读取的文件的起始下标
    	  private int endIndex; // 要读取的文件的结束下标
    	  private Socket socket; // 客户端对象
    	  public UploadClient(File file, int index, int endIndex, Socket socket){
    	    // 赋值
    	  }
    	  public Object call(){
    	    RandomAccessFile raf = new RandomAccessFile(file);
    	    raf.skipBytes(index);
    	    byte[] temp = new byte[endIndex - index];
    	    raf.read(temp, index, endIndex - index);
    	    OutputStream output = socket.getOutputStream();
    	    // 通知服务器,本次连接上传的是那一个文件,是这个文件的那一个部分。
    	    output.write("{\"filename\"=\"\",\"index\"=?,\"endIndex\"=?}".getBytes());
    	    // 通知服务器,描述信息结束,后续的都是文件内容。
    	    output.write("\n".getBytes());
    	    output.flush();
    	    output.write(temp);
    	    output.flush();
    	    raf.close();
    	    socket.close();
    
    	    return "ok";
    	  }
    	}
    

    server:

      class ServerMain{
    	  public static void main(String [] args){
    	    ServerSocket ss = new ServerSocket(port);
    	    while(true){
    	      Socket s = ss.accept();
    	      new Thread(new ServerHandler(s)).start();
    	    }
    	  }
    	}
    	class ServerHandler implements Runnable{
    	  private Socket s;
              public ServerHandler(Socket s){}
    	  public void run(){
    	    InputStream input = s.getInputStream();
    	    BufferedReader reader = new BufferedReader(input);
    	    String line = reader.readLine();
    	    // 处理字符串line,如果是{filename:xxx}, 创建文件
    	    ObjectMapper om = new ObjectMapper();
    	    Map map = om.readObject(line, Map.class);
    	    if(map.size() == 1){// 创建文件}
    	    else{// 多线程写入操作
    	      // 读取文件内容,做写入操作
                  String filename = map.get("filename");
    	      long index = map.get("index");
    	      long endIndex = map.get("endIndex");
    	      RandomAccessFile raf = new RandomAccessFile(filename, "append");
    	      raf.skipBytes(index);
    	      input.read();
    	      raf.write();
    	    }
    	  }
    	}
    
    

    迅雷

    java编写简单的Socket通信应用 实现服务端同时处理多个客户端

    java socket 多线程网络传输多个文件

    展开全文
  • 一有客户端连接就创建两个新的线程来负责这个连接一个负责客62616964757a686964616fe59b9ee7ad9431333262373934户端发送的信息(ClientMsgCollectThread 类),另一个负责通过该Socket发送数据(ServerMsgSendThread )...

    展开全部

    程序分Server和Client

    服务器端打开侦听的端口,一有客户端连接就创建两个新的线程来负责这个连接

    一个负责客62616964757a686964616fe59b9ee7ad9431333262373934户端发送的信息(ClientMsgCollectThread 类),

    另一个负责通过该Socket发送数据(ServerMsgSendThread )

    Server.java代码如下:

    /*

    * 创建日期 2009-3-7

    *

    * TODO 要更改此生成的文件的模板,请转至

    * 窗口 - 首选项 - Java - 代码样式 - 代码模板

    */

    package faue.MutiUser;

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.io.PrintWriter;

    import java.net.ServerSocket;

    import java.net.Socket;

    /**

    * 服务器端

    *

    * @author Faue

    */

    public class Server extends ServerSocket {

    private static final int SERVER_PORT = 10000;

    /**

    * 构造方法,用于实现连接的监听

    *

    * @throws IOException

    */

    public Server() throws IOException {

    super(SERVER_PORT);

    try {

    while (true) {

    Socket socket = super.accept();

    new Thread(new ClientMsgCollectThread(socket), "getAndShow"

    + socket.getPort()).start();

    new Thread(new ServerMsgSendThread(socket), "send"

    + socket.getPort()).start();

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

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

    new Server();

    }

    /**

    * 该类用于创建接收客户端发来的信息并显示的线程

    *

    * @author Faue

    * @version 1.0.0

    */

    class ClientMsgCollectThread implements Runnable {

    private Socket client;

    private BufferedReader in;

    private StringBuffer inputStringBuffer = new StringBuffer("Hello");

    /**

    * 得到Socket的输入流

    *

    * @param s

    * @throws IOException

    */

    public ClientMsgCollectThread(Socket s) throws IOException {

    client = s;

    in = new BufferedReader(new InputStreamReader(client

    .getInputStream(), "GBK"));

    }

    public void run() {

    try {

    while (!client.isClosed()) {

    inputStringBuffer.delete(0, inputStringBuffer.length());

    inputStringBuffer.append(in.readLine());

    System.out.println(getMsg(inputStringBuffer.toString()));

    }

    } catch (IOException e) {

    //e.printStackTrace();

    System.out.println(client.toString() + " is closed!");

    }

    }

    /**

    * 构造显示的字符串

    *

    * @param line

    * @return

    */

    private String getMsg(String line) {

    return client.toString() + " says:" + line;

    }

    }

    /**

    * 该类用于创建发送数据的线程

    *

    * @author Faue

    * @version 1.0.0

    */

    class ServerMsgSendThread implements Runnable {

    private Socket client;

    private PrintWriter out;

    private BufferedReader keyboardInput;

    private StringBuffer outputStringBuffer = new StringBuffer("Hello");

    /**

    * 得到键盘的输入流

    *

    * @param s

    * @throws IOException

    */

    public ServerMsgSendThread(Socket s) throws IOException {

    client = s;

    out = new PrintWriter(client.getOutputStream(), true);

    keyboardInput = new BufferedReader(new InputStreamReader(System.in));

    }

    public void run() {

    try {

    while (!client.isClosed()) {

    outputStringBuffer.delete(0, outputStringBuffer.length());

    outputStringBuffer.append(keyboardInput.readLine());

    out.println(outputStringBuffer.toString());

    }

    } catch (IOException e) {

    //e.printStackTrace();

    System.out.println(client.toString() + " is closed!");

    }

    }

    }

    }

    客户端:

    实现基于IP地址的连接,连接后也创建两个线程来实现信息的发送和接收

    /*

    * 创建日期 2009-3-7

    *

    */

    package faue.MutiUser;

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.io.PrintWriter;

    import java.net.Socket;

    /**

    * 客户端

    *

    * @author Faue

    */

    public class Client {

    private Socket mySocket;

    /**

    * 创建线程的构造方法

    *

    * @param IP

    * @throws IOException

    */

    public Client(String IP) throws IOException {

    try {

    mySocket = new Socket(IP, 10000);

    new Thread(new ServerMsgCollectThread(mySocket), "getAndShow"

    + mySocket.getPort()).start();

    new Thread(new ClientMsgSendThread(mySocket), "send"

    + mySocket.getPort()).start();

    } catch (IOException e) {

    //e.printStackTrace();

    System.out.println("Server.IP:" + IP

    + " port:10000 can not be Connected");

    }

    }

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

    try {

    new Client(args[0]);

    } catch (Exception e) {

    System.out.println("输入的IP地址错误");

    }

    }

    /**

    * 该类用于创建接收服务端发来的信息并显示的线程

    *

    * @author Faue

    * @version 1.0.0

    */

    class ServerMsgCollectThread implements Runnable {

    private Socket client;

    private BufferedReader in;

    private StringBuffer inputStringBuffer = new StringBuffer("Hello");

    /**

    * 得到Socket的输入流

    *

    * @param s

    * @throws IOException

    */

    public ServerMsgCollectThread(Socket s) throws IOException {

    client = s;

    in = new BufferedReader(new InputStreamReader(client

    .getInputStream(), "GBK"));

    }

    public void run() {

    try {

    while (!client.isClosed()) {

    inputStringBuffer.delete(0, inputStringBuffer.length());

    inputStringBuffer.append(in.readLine());

    System.out.println(getMsg(inputStringBuffer.toString()));

    }

    } catch (IOException e) {

    //e.printStackTrace();

    System.out.println(client.toString() + " is closed!");

    System.exit(0);

    }

    }

    /**

    * 构造输入字符串

    *

    * @param line

    * @return

    */

    private String getMsg(String line) {

    return client.toString() + " says:" + line;

    }

    }

    /**

    * 该类用于创建发送数据的线程

    *

    * @author Faue

    * @version 1.0.0

    */

    class ClientMsgSendThread implements Runnable {

    private Socket client;

    private PrintWriter out;

    private BufferedReader keyboardInput;

    private StringBuffer outputStringBuffer = new StringBuffer("Hello");

    /**

    * 得到键盘的输入流

    *

    * @param s

    * @throws IOException

    */

    public ClientMsgSendThread(Socket s) throws IOException {

    client = s;

    out = new PrintWriter(client.getOutputStream(), true);

    keyboardInput = new BufferedReader(new InputStreamReader(System.in));

    }

    public void run() {

    try {

    while (!client.isClosed()) {

    outputStringBuffer.delete(0, outputStringBuffer.length());

    outputStringBuffer.append(keyboardInput.readLine());

    out.println(outputStringBuffer.toString());

    }

    out.println("--- See you, bye! ---");

    } catch (IOException e) {

    //e.printStackTrace();

    System.out.println(client.toString() + " is closed!");

    System.exit(0);

    }

    }

    }

    }

    如果对您有帮助,请记得采纳为满意答案,谢谢!祝您生活愉快!

    vaela

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • javaweb上传文件上传文件的jsp中的部分上传文件同样可以使用form表单向后端发请求,也可以使用 ajax向后端发请求1.通过form表单向后端发送请求Save改进后的代码不需要form标签,直接由控件来实现。开发人员只需要...

    javaweb上传文件

    上传文件的jsp中的部分

    上传文件同样可以使用form表单向后端发请求,也可以使用 ajax向后端发请求

    1. 通过form表单向后端发送请求

    Save

    改进后的代码不需要form标签,直接由控件来实现。开发人员只需要关注业务逻辑即可。JS中已经帮我们封闭好了

    58167d3644248921dd6e8cb601254f3d.png

    通过监控工具可以看到控件提交的数据,非常的清晰,调试也非常的简单。

    9b0b4a45ca43bdf5ecedf5a3f364ba0f.png

    2. 通过ajax向后端发送请求

    1.

    $.ajax({

    url : "${pageContext.request.contextPath}/UploadServlet",

    type : "POST",

    data : $( '#postForm').serialize(),

    success : function(data) {

    $( '#serverResponse').html(data);

    },

    error : function(data) {

    $( '#serverResponse').html(data.status + " : " + data.statusText + " : " + data.responseText);

    }

    });

    ajax分为两部分,一部分是初始化,文件在上传前通过AJAX请求通知服务端进行初始化操作

    41de38545fc266a00cdd12b20ab58daf.png

    在文件上传完后向服务器发送通知

    c55be86c8014a56634c2ce97900d565e.png

    这里需要处理一个MD5秒传的逻辑,当服务器存在相同文件时,不需要用户再上传,而是直接通知用户秒传

    275e7c224e6f3aea3acce053d145b35d.png

    这里可以看到秒传的逻辑是非常 简单的,并不是特别的复杂。

    var form = new FormData();

    form.append("username","zxj");

    form.append("avatar",file);

    //var form = new FormData($("#postForm")[0]);

    $.ajax({

    url:"${pageContext.request.contextPath}/UploadServlet",

    type:"post",

    data:form,

    processData:false,

    contentType:false,

    success:function(data){

    console.log(data);

    }

    });

    java部分

    文件初始化的逻辑

    7da43c7691b16af9d09dafa4c6743f41.png

    接收文件块数据,在这个逻辑中我们接收文件块数据。控件对数据进行了优化,可以方便调试。如果用监控工具可以看到控件提交的数据。

    7e638be1553beb7bb4d89829e20196be.png

    注:

    1. 上面的java部分的代码可以直接使用,只需要将上传的图片路径及收集数据并将数据写入到数据库即可

    2. 上面上传文件使用到了字节流,其实还可以使用别的流,这个需要读者自己在下面完善测试

    3. BeanUtils是一个工具 便于将实体对应的属性赋给实体

    4. 上传文件不能使用 request.getParameter("")获取参数了,而是直接将request解析,通过判断每一项是文件还是非文件,然后进行相应的操作(文件的话就是用流来读取,非文件的话,暂时保存到一个map中。)

    欢迎入群一起讨论:374992201

    展开全文
  • 思路:1、基本思路是将文件分段切割、分段传输、分段保存。2、分段切割用到HttpUrlConnection对象的setRequestProperty("Range", "bytes=" + start + "-" + end)方法。3、分段传输用到HttpUrlConnection对象的...
  • 由于要需究研了下用java socket传输文件,由于要需传输多个文件,因此,采用了多线程计设。客户端个每线程创立一个socket连接,个每socket连接担任传输一个文件,服务端的ServerSocket每次accept一个socket连接,...
  • java 文件传输 客户端 传输文件[2021-01-30 10:02:05]简介:服务器一、进程与线程二、vsftp服务器1.文件传输协议(file transfer protocol,FTP)基于该协议ftp客户端和服务端实现文件共享,传输文件的方式有哪些...
  • 展开全部程序分Server和Client服务器端打开侦听的端口,一有客户端连接就创建两个新的线程来负责这个连32313133353236313431303231363533e59b9ee7ad9431333264623330接一个负责客户端发送的信息...
  • Java 两种简单的方式实现多线程】 【Java ExecutorService管理线程池的简单用法】 【JAVA URLConnection 实现下载小文件】 单一线程下载文件的步骤 建立URLConnection对象并获取输入流 建立文件输出流 将输入流的...
  • 采用Java语言实现了TCP和UDP传输,TCP方面具体功能有:在客户端获取服务器根目录下文件列表、大小等,进入指定文件夹,退出文件夹;UDP方面的功能有:在客户端通过get方法获取服务器指定文件并下载到指定路径。
  • 因为要用Java,Socket&TCP编程实现多线程端对端通信与文件传输,现学的Java
  • Java线程 进程:内存中运行的应用程序,每个进程拥有自己独立的一块内存空间 线程:进程中一个执行流程,线程没有自己的虚拟地址空间,与进程内其他线程共享该进程的所有资源 并发:线程之间轮换执行 创建线程 new ...
  • Java实现多线程下载

    2019-09-28 05:25:45
    1、基本思路是将文件分段切割、分段传输、分段保存。 2、分段切割用到HttpUrlConnection对象的setRequestProperty("Range", "bytes=" + start + "-" + end)方法。 3、分段传输用到HttpUrlConnection对象的...
  • C#(C Sharp)是微软(Microsoft)为.NET Framework量身订做的程序语言,C#拥有C/C++的强大功能以及Visual Basic简易使用的特性,是第一个...下面主要介绍的是用C#实现HTTP协议下的多线程文件传输。 很多人都有过使用
  • 多线程实现文件上传 需求: 客户端:数据来自于文本文件,接收服务器反馈 服务器:接收到的数据写入文本文件,给出反馈,代码用线程进行封装,为每一个客户端开启一个线程 分析: 创建客户端对象,创建输入流...
  • 展开全部importjava.io.BufferedReader;importjava.io.BufferedWriter;importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.PipedInpu...
  • java p2p多文件传输程序的实现

    千次阅读 2009-06-13 15:12:00
    java p2p多文件传输程序的实现,主要利用了java中的socket,SocketThread类,下面是实现过程,Server.java类,//psp文件传输服务,SocketThread.java//文件传输线程类,Application1.java import java.net.*;...
  • java socket 多线程 断点续传实现

    热门讨论 2014-01-07 11:32:22
    最近研究了一下socket套接字 实现java多线程 断点续传文件 在网上查找了很多例子 然后学习了大家的方法 最后利用网上的例子 自己整合了一份多线程 断点续传文件的代码 并且能实现客户端发送完毕之后 接收服务器端的...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 318
精华内容 127
关键字:

java实现多线程文件传输

java 订阅