tttt

最新推荐文章于 2024-06-15 20:43:16 发布

amaryh

最新推荐文章于 2024-06-15 20:43:16 发布

阅读量1.8k

点赞数

文章标签：任务 thread file 多线程 string list

使用Java多线程实现任务分发
多线程下载由来已久，如 FlashGet、NetAnts 等工具，它们都是依懒于 HTTP 协议的支持（Range 字段指定请求内容范围），首先能读取出请求内容（即欲下载的文件）的大小，划分出若干区块，把区块分段分发给每个线程去下载，线程从本段起始处下载数据及至段尾，多个线程下载的内容最终会写入到同一个文件中。

只研究有用的，工作中的需求：要把多个任务分派给Java的多个线程去执行，这其中就会有一个任务列表指派到线程的策略思考：已知：1. 一个待执行的任务列表，2. 指定要启动的线程数；问题是：每个线程实际要执行哪些任务。

使用Java多线程实现这种任务分发的策略是：任务列表连续按线程数分段，先保证每线程平均能分配到的任务数，余下的任务从前至后依次附加到线程中——只是数量上，实际每个线程执行的任务都还是连续的。如果出现那种僧多（线程）粥（任务）少的情况，实际启动的线程数就等于任务数，一挑一。这里只实现了每个线程各扫自家门前雪，动作快的完成后眼见别的线程再累都是爱莫能助。

实现及演示代码如下：由三个类实现，写在了一个 Java 文件中：TaskDistributor 为任务分发器，Task 为待执行的任务，WorkThread 为自定的工作线程。代码中运用了命令模式，如若能配以监听器，用上观察者模式来控制 UI 显示就更绝妙不过了，就能实现像下载中的区块着色跳跃的动感了，在此定义下一步的着眼点了。

代码中有较为详细的注释，看这些注释和执行结果就很容易理解的。main（）是测试方法

package com.unmi.common;
import java.util.ArrayList;
import java.util.List;
/**
* 指派任务列表给线程的分发器
* @author Unmi
* QQ: 1125535 Email: fantasia@sina.com
* MSN: kypfos@msn.com 2008-03-25
*/
public class TaskDistributor {
/**
* 测试方法
* @param args
*/
public static void main(String[] args) {
//初始化要执行的任务列表
List taskList = new ArrayList();
for (int i = 0; i < 108; i++) {
taskList.add(new Task(i));
}
//设定要启动的工作线程数为 5 个
int threadCount = 5;
List[] taskListPerThread = distributeTasks(taskList, threadCount);
System.out.println("实际要启动的工作线程数："+taskListPerThread.length);
for (int i = 0; i < taskListPerThread.length; i++) {
Thread workThread = new WorkThread(taskListPerThread[i],i);
workThread.start();
}
}
/**
* 把 List 中的任务分配给每个线程，先平均分配，剩于的依次附加给前面的线程
* 返回的数组有多少个元素 (List) 就表明将启动多少个工作线程
* @param taskList 待分派的任务列表
* @param threadCount 线程数
* @return 列表的数组，每个元素中存有该线程要执行的任务列表
*/
public static List[] distributeTasks(List taskList, int threadCount) {
// 每个线程至少要执行的任务数,假如不为零则表示每个线程都会分配到任务
int minTaskCount = taskList.size() / threadCount;
// 平均分配后还剩下的任务数，不为零则还有任务依个附加到前面的线程中
int remainTaskCount = taskList.size() % threadCount;
// 实际要启动的线程数,如果工作线程比任务还多
// 自然只需要启动与任务相同个数的工作线程，一对一的执行
// 毕竟不打算实现了线程池，所以用不着预先初始化好休眠的线程
int actualThreadCount = minTaskCount > 0 ? threadCount : remainTaskCount;
// 要启动的线程数组，以及每个线程要执行的任务列表
List[] taskListPerThread = new List[actualThreadCount];
int taskIndex = 0;
//平均分配后多余任务，每附加给一个线程后的剩余数，重新声明与 remainTaskCount
//相同的变量，不然会在执行中改变 remainTaskCount 原有值，产生麻烦
int remainIndces = remainTaskCount;
for (int i = 0; i < taskListPerThread.length; i++) {
taskListPerThread[i] = new ArrayList();
// 如果大于零，线程要分配到基本的任务
if (minTaskCount > 0) {
for (int j = taskIndex; j < minTaskCount + taskIndex; j++) {
taskListPerThread[i].add(taskList.get(j));
}
taskIndex += minTaskCount;
}
// 假如还有剩下的，则补一个到这个线程中
if (remainIndces > 0) {
taskListPerThread[i].add(taskList.get(taskIndex++));
remainIndces--;
}
}
// 打印任务的分配情况
for (int i = 0; i < taskListPerThread.length; i++) {
System.out.println("线程 " + i + " 的任务数：" +

taskListPerThread[i].size() + " 区间["
+ taskListPerThread[i].get(0).getTaskId() + ","
+ taskListPerThread[i].get(taskListPerThread[i].size() - 1).getTaskId() + "]");
}
return taskListPerThread;
}
}
/**
* 要执行的任务，可在执行时改变它的某个状态或调用它的某个操作
* 例如任务有三个状态，就绪，运行，完成，默认为就绪态
* 要进一步完善，可为 Task 加上状态变迁的监听器，因之决定UI的显示
*/
class Task {
public static final int READY = 0;
public static final int RUNNING = 1;
public static final int FINISHED = 2;
private int status;
//声明一个任务的自有业务含义的变量，用于标识任务
private int taskId;
//任务的初始化方法
public Task(int taskId){
this.status = READY;
this.taskId = taskId;
}
/**
* 执行任务
*/
public void execute() {
// 设置状态为运行中
setStatus(Task.RUNNING);
System.out.println("当前线程 ID 是：" + Thread.currentThread().getName()
+" | 任务 ID 是："+this.taskId);
// 附加一个延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 执行完成，改状态为完成
setStatus(FINISHED);
}
public void setStatus(int status) {
this.status = status;
}
public int getTaskId() {
return taskId;
}
}
/**
* 自定义的工作线程，持有分派给它执行的任务列表
*/
class WorkThread extends Thread {
//本线程待执行的任务列表，你也可以指为任务索引的起始值
private List taskList = null;
private int threadId;
/**
* 构造工作线程，为其指派任务列表，及命名线程 ID
* @param taskList 欲执行的任务列表
* @param threadId 线程 ID
*/
public WorkThread(List taskList,int threadId) {
this.taskList = taskList;
this.threadId = threadId;
}
/**
* 执行被指派的所有任务
*/
public void run() {
for (Task task : taskList) {
task.execute();
}
}
}

执行结果如下，注意观察每个Java多线程分配到的任务数量及区间。直到所有的线程完成了所分配到的任务后程序结束：

上面坦白来只算是基本功夫，贴出来还真见笑了。还有更为复杂的功能。

像Java多线程的下载工具的确更充分利用了网络资源，而且像 FlashGet、NetAnts 都实现了：假如某个线程下载完了欲先所分配段的内容之后，会帮其他线程下载未完成数据，直到任务完成；或某一下载线程的未完成段区间已经很小了，用不着别人来帮忙时，这就涉及到任务的进一步分配。再如，以上两个工具都能动态增加、减小或中止线程，越说越复杂了，它们原本比这复杂多了，这些实现可能定义各种队列来实现，如未完成任务队列、下载中任务队列和已完成队列等。

package download;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
*
* @author annegu
* @since 2009-07-16
*
*/
public class DownloadTask {

// private static transient
// 分段下载的线程个数
private int threadNum = 5;
private URL url = null;
private long threadLength = 0;
// 目标文件路径与名字
public String fileDir = "E:/concurrent/";
public String fileName = "test";
public boolean statusError = false;
private String charset;

public long sleepSeconds = 5;

public String download(String urlStr, String charset) {
  statusError = false;
  this.charset = charset;
  long contentLength = 0;
  CountDownLatch latch = new CountDownLatch(threadNum);
  ChildThread[] childThreads = new ChildThread[threadNum];
  long[] startPos = new long[threadNum];
  long[] endPos = new long[threadNum];

  try {
   // 从url中获得下载的文件格式与名字
   this.fileName = urlStr.substring(urlStr.lastIndexOf("/") + 1,
     urlStr.lastIndexOf("?") > 0 ? urlStr.lastIndexOf("?")
       : urlStr.length());
   if ("".equalsIgnoreCase(this.fileName)) {
    this.fileName = UUID.randomUUID().toString();
   }

   File file = new File(fileDir + fileName);
   File tempFile = new File(fileDir + fileName + "_temp");

   this.url = new URL(urlStr);
   HttpURLConnection con = (HttpURLConnection) url.openConnection();
   setHeader(con);
   // 得到content的长度
   contentLength = con.getContentLength();
   // 把context分为threadNum段的话，每段的长度。
   this.threadLength = contentLength / threadNum;

// 第一步，分析已下载的临时文件，设置断点，如果是新的下载任务，则建立目标文件。
setThreadBreakpoint(file, tempFile, contentLength, startPos, endPos);

   // 第二步，分多个线程下载文件
   ExecutorService exec = Executors.newCachedThreadPool();
   for (int i = 0; i < threadNum; i++) {

    // 开启子线程，并执行。
    ChildThread thread = new ChildThread(this, latch, i,
      startPos[i], endPos[i]);
    childThreads[i] = thread;
    exec.execute(thread);
   }

   try {
    // 等待CountdownLatch信号为0，表示所有子线程都结束。
    latch.await();
    exec.shutdown();

    // 删除临时文件
    long downloadFileSize = file.length();
    if (downloadFileSize == contentLength) {
     tempFile.delete();
    }

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

return fileDir + fileName;
}

private void setThreadBreakpoint(File file, File tempFile,
   long contentLength, long[] startPos, long[] endPos) {
  RandomAccessFile tempFileFos = null;
  try {
   if (file.exists()) {
    System.out.println("file " + fileName + " has exists!");

    long localFileSize = file.length();
    // 下载的目标文件已存在，判断目标文件是否完整
    if (localFileSize < contentLength) {
     System.out.println("Now download continue ... ");

     tempFileFos = new RandomAccessFile(tempFile, "rw");
     // 遍历目标文件的所有临时文件，设置断点的位置，即每个临时文件的长度
     for (int i = 0; i < threadNum; i++) {
      tempFileFos.seek(4 + 24 * i + 8);
      endPos[i] = tempFileFos.readLong();

      tempFileFos.seek(4 + 24 * i + 16);
      startPos[i] = tempFileFos.readLong();
     }
    } else {
     System.out.println("This file has download complete!");
    }

   } else {
    // 如果下载的目标文件不存在，则创建新文件
    file.createNewFile();
    tempFile.createNewFile();
    tempFileFos = new RandomAccessFile(tempFile, "rw");
    tempFileFos.writeInt(threadNum);

for (int i = 0; i < threadNum; i++) {

     // 创建子线程来负责下载数据，每段数据的起始位置为(threadLength * i)
     startPos[i] = threadLength * i;
     tempFileFos.writeLong(startPos[i]);

     /*
      * 设置子线程的终止位置，非最后一个线程即为(threadLength * (i + 1) - 1)
      * 最后一个线程的终止位置即为下载内容的长度
      */
     if (i == threadNum - 1) {
      endPos[i] = contentLength;
     } else {
      endPos[i] = threadLength * (i + 1) - 1;
     }
     // end position
     tempFileFos.writeLong(endPos[i]);
     // current position
     tempFileFos.writeLong(startPos[i]);
    }
   }
  } catch (IOException e1) {
   e1.printStackTrace();
  } finally {
   try {
    tempFileFos.close();
   } catch (IOException e2) {
    e2.printStackTrace();
   }
  }
}

/**
*
* @author annegu
* @since 2009-07-16
*
*/
public class ChildThread extends Thread {
  private DownloadTask task;
  private int id;
  private long startPosition;
  private long endPosition;
  private final CountDownLatch latch;
  private RandomAccessFile file = null;
  private RandomAccessFile tempFile = null;

  public ChildThread(DownloadTask task, CountDownLatch latch, int id,
    long startPos, long endPos) {
   super();
   this.task = task;
   this.id = id;
   this.startPosition = startPos;
   this.endPosition = endPos;
   this.latch = latch;

   try {
    file = new RandomAccessFile(this.task.fileDir
      + this.task.fileName, "rw");
    tempFile = new RandomAccessFile(this.task.fileDir
      + this.task.fileName + "_temp", "rw");
   } catch (IOException e) {
    e.printStackTrace();
   }
  }

  public void run() {
   System.out.println("Thread " + id + " run ...");
   HttpURLConnection con = null;
   InputStream inputStream = null;
   long count = 0;

   try {
    System.out.println(id + "===1 ====" + tempFile.readInt());
    tempFile.seek(4 + 24 * id);
    System.out.println(id + "===2 ====" + tempFile.readLong());
    System.out.println(id + "===3 ====" + tempFile.readLong());
    System.out.println(id + "===4 ====" + tempFile.readLong());
   } catch (IOException e2) {
    e2.printStackTrace();
   }

   for (;;) {
    try {
     // 打开URLConnection
     con = (HttpURLConnection) task.url.openConnection();
     setHeader(con);
     // 设置连接超时时间为10000ms
     con.setConnectTimeout(10000);
     // 设置读取数据超时时间为10000ms
     con.setReadTimeout(10000);

     if (startPosition < endPosition) {
      // 设置下载数据的起止区间
      con.setRequestProperty("Range", "bytes="
        + startPosition + "-" + endPosition);
      System.out.println("Thread " + id
        + " startPosition is " + startPosition
        + ", and endPosition is " + endPosition);

file.seek(startPosition);

      // 判断http status是否为HTTP/1.1 206 Partial Content或者200 OK
      // 如果不是以上两种状态，把status改为STATUS_HTTPSTATUS_ERROR
      if (con.getResponseCode() != HttpURLConnection.HTTP_OK
        && con.getResponseCode() != HttpURLConnection.HTTP_PARTIAL) {
       System.out.println("Thread " + id + ": code = "
         + con.getResponseCode() + ", status = "
         + con.getResponseMessage());
       this.task.statusError = true;
       file.close();
       con.disconnect();
       System.out.println("Thread " + id + " finished.");
       latch.countDown();
       break;
      }

      inputStream = con.getInputStream();
      int len = 0;
      byte[] b = new byte[1024];
      while (!this.task.statusError
        && (len = inputStream.read(b)) != -1) {
       file.write(b, 0, len);

count += len;
startPosition += len;

       // set tempFile now position
       tempFile.seek(4 + 24 * id + 16);
       tempFile.writeLong(startPosition);
      }

      file.close();
      tempFile.close();
      inputStream.close();
      con.disconnect();
     }

     System.out.println("Thread " + id + " finished.");
     latch.countDown();
     break;
    } catch (IOException e) {
     try {
      // outputStream.flush();
      TimeUnit.SECONDS.sleep(getSleepSeconds());
     } catch (InterruptedException e1) {
      e1.printStackTrace();
     }
     continue;
    }
   }
  }
}

private void setHeader(URLConnection con) {
  con
    .setRequestProperty(
      "User-Agent",
      "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.3) Gecko/2008092510 Ubuntu/8.04 (hardy) Firefox/3.0.3");
  con.setRequestProperty("Accept-Language", "en-us,en;q=0.7,zh-cn;q=0.3");
  con.setRequestProperty("Accept-Encoding", "aa");
  con.setRequestProperty("Accept-Charset",
    "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
  con.setRequestProperty("Keep-Alive", "300");
  con.setRequestProperty("Connection", "keep-alive");
  con.setRequestProperty("If-Modified-Since",
    "Fri, 02 Jan 2009 17:00:05 GMT");
  con.setRequestProperty("If-None-Match", "/"1261d8-4290-df64d224/"");
  con.setRequestProperty("Cache-Control", "max-age=0");
  con.setRequestProperty("Referer",
    "http://www.skycn.com/soft/14857.html");
}

public long getSleepSeconds() {
return sleepSeconds;
}

public void setSleepSeconds(long sleepSeconds) {
this.sleepSeconds = sleepSeconds;
}

}

amaryh

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
tttt

使用Java多线程实现任务分发多线程下载由来已久，如 FlashGet、NetAnts 等工具，它们都是依懒于 HTTP 协议的支持（Range 字段指定请求内容范围），首先能读取出请求内容（即欲下载的文件）的大小，划分出若干区块，把区块分段分发给每个线程去下载，线程从本段起始处下载数据及至段尾，多个线程下载的内容最终会写入到同一个文件中。只研究有用的，工作中的需求：要把
复制链接

扫一扫