网站建设资讯

NEWS

网站建设资讯

Java如何实现手写线程池

这篇文章主要为大家展示了“Java如何实现手写线程池”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“Java如何实现手写线程池”这篇文章吧。

目前创新互联已为超过千家的企业提供了网站建设、域名、雅安服务器托管网站托管、企业网站设计、盘州网站维护等服务,公司将坚持客户导向、应用为本的策略,正道将秉承"和谐、参与、激情"的文化,与客户和合作伙伴齐心协力一起成长,共同发展。

具体内容如下

1.线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。线程池线程都是后台线程。

2.线程池简易架构

Java如何实现手写线程池

3.简易线程池代码(自行优化)

import java.util.List;

/**
 * 线程接口
 *
 * @Author yjian
 * @Date 14:49 2017/10/14
 **/
public interface IThreadPool {
 //加入任务
 void execute(Runnable task);

 //加入任务
 void execute(Runnable[] tasks);

 //加入任务
 void execute(List tasks);

 //销毁线程
 void destroy();
}
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 线程实现类(简易实现,自行优化.提供思路)
 *
 * @Author yjian
 * @Date 14:49 2017/10/14
 **/
@SuppressWarnings("ALL")
public class ThreadPoolImpl implements IThreadPool {
 //默认开启线程个数
 static int WORKER_NUMBER = 5;
 //完成任务线程数 可见性
 static volatile int sumCount = 0;
 //任务队列 list非线程安全,可以优化为BlockingQueue
 static List taskQueue = new LinkedList();
 //线程工作组
 WorkerThread[] workThreads;
 //原子性
 static AtomicLong threadNum = new AtomicLong();

 static ThreadPoolImpl threadPool;

 //构造方法
 public ThreadPoolImpl() {
  this(WORKER_NUMBER);
 }

 public ThreadPoolImpl(int workerNum) {
  this.WORKER_NUMBER = workerNum;
  //开辟工作线程空间
  workThreads = new WorkerThread[WORKER_NUMBER];
  //开始创建工作线程
  for (int i = 0; i < WORKER_NUMBER; i++) {
   workThreads[i] = new WorkerThread();
   Thread thread = new Thread(workThreads[i], "ThreadPool-worker" + threadNum.incrementAndGet());
   System.out.println("初始化线程数" + (i + 1) + "---------当前线程名称:" + thread.getName());
   thread.start();
  }
 }

 @Override
 public String toString() {
  return "工作线程数量为" + WORKER_NUMBER
    + "已完成的任务数" + sumCount +
    "等待任务数量" + taskQueue.size();
 }


 //获取线程池
 public static IThreadPool getThreadPool() {
  return getThreadPool(WORKER_NUMBER);
 }

 public static IThreadPool getThreadPool(int workerNum) {
  //容错性,如果小于等于0就默认线程数
  if (workerNum <= 0) {
   workerNum = WORKER_NUMBER;
  }
  if (threadPool == null) {
   threadPool = new ThreadPoolImpl(workerNum);
  }
  return threadPool;
 }


 @Override
 public void execute(Runnable task) {
  synchronized (taskQueue) {
   taskQueue.add(task);
   taskQueue.notifyAll();
  }
 }

 @Override
 public void execute(Runnable[] tasks) {
  synchronized (taskQueue) {
   for (Runnable task : tasks) {
    taskQueue.add(task);
   }
   taskQueue.notifyAll();
  }
 }

 @Override
 public void execute(List tasks) {
  synchronized (taskQueue) {
   for (Runnable task : tasks) {
    taskQueue.add(task);
   }
   taskQueue.notifyAll();
  }
 }

 @Override
 public void destroy() {
  //循环是否还存在任务,如果存在等待20毫秒处理时间
  while (!taskQueue.isEmpty()) {
   try {
    Thread.sleep(20);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  //如果任务队列已处理完成,销毁线程,清空任务
  for (int i = 0; i < WORKER_NUMBER; i++) {
   workThreads[i].setWorkerFlag();
   workThreads[i] = null;
  }
  threadPool = null;
  taskQueue.clear();
 }

 //创建工作线程池
 class WorkerThread extends Thread {
  //用来标识当前线程属于活动可用状态
  private boolean isRunning = true;

  @Override
  public void run() {
   Runnable runnable = null;
   //死循环
   while (isRunning) {
    //非线程安全,所以采用同步锁
    synchronized (taskQueue) {
     while (isRunning && taskQueue.isEmpty()) {
      try {
       //如果任务队列为空,等待20毫秒 监听任务到达
       taskQueue.wait(20);
      } catch (Exception e) {
       e.printStackTrace();
      }
     }
     //任务队列不为空
     if (!taskQueue.isEmpty()) {
      runnable = taskQueue.remove(0);//获取第一个任务
     }
    }
    if (runnable != null) {
     runnable.run();
    }
    sumCount++;
    runnable = null;
   }
  }

  //销毁线程
  public void setWorkerFlag() {
   isRunning = false;
  }
 }
}
import java.util.ArrayList;
import java.util.List;

/**
 * 测试类
 *
 * @Author yjian
 * @Date 15:37 2017/10/14
 **/
public class ThreadPoolTest {


 public static void main(String[] args) {
  //获取线程池
  IThreadPool t = ThreadPoolImpl.getThreadPool(20);

  List taskList = new ArrayList();
  for (int i = 0; i < 100; i++) {
   taskList.add(new Task());
  }
  //执行任务
  t.execute(taskList);
  System.out.println(t);
  //销毁线程
  t.destroy();
  System.out.println(t);
 }

 static class Task implements Runnable {

  private static volatile int i = 1;

  @Override
  public void run() {
   System.out.println("当前处理的线程:" + Thread.currentThread().getName() + " 执行任务" + (i++) + " 完成");
  }
 }

}

对spring源码研究的,仔细查看代码用了哪几种spring常用的模式。写程序的规范应该和spring一样。

以上是“Java如何实现手写线程池”这篇文章的所有内容,感谢各位的阅读!相信大家都有了一定的了解,希望分享的内容对大家有所帮助,如果还想学习更多知识,欢迎关注创新互联行业资讯频道!


当前名称:Java如何实现手写线程池
文章源于:http://cdweb.net/article/gecjcc.html