자바 핸드폰 스 레 드 탱크 의 실현 방법

본 논문 의 사례 는 자바 손 으로 스 레 드 탱크 의 실현 코드 를 공유 하여 여러분 께 참고 하 시기 바 랍 니 다.구체 적 인 내용 은 다음 과 같 습 니 다.
1.스 레 드 탱크 는 다 중 스 레 드 처리 형식 으로 처리 과정 에서 작업 을 대기 열 에 추가 한 다음 스 레 드 를 만 든 후에 이 작업 을 자동 으로 시작 합 니 다.스 레 드 탱크 스 레 드 는 모두 백 스테이지 스 레 드 입 니 다.
2.스 레 드 탱크 간이 구조

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<Runnable> 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<Runnable> taskQueue = new LinkedList<Runnable>();
 //     
 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<Runnable> 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<Runnable> taskList = new ArrayList<Runnable>();
  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 과 같 아야 합 니 다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.