不同的線程交替打印數字 按照升序或者倒序輸出

package coma.laozhao.resume;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 *  指定線程數 
 *  按序輸出
**/
public class OrderNumWithNumThreadWithDESC {
  private int maxNum;
  private int threadNum;
  private Boolean asc;//升序或者降序
  
  public OrderNumWithNumThreadWithDESC(int maxNum,int threadNum,Boolean asc) {
	  this.maxNum=maxNum;
	  this.threadNum=threadNum;
	  this.asc=asc==null?true:asc;  
  }
  
  public  void init() {
	 // 計算間隔；
	  if(maxNum<threadNum) {
		  System.out.println(" 最大輸出數字 不小於指定的線程數");
		  return;
	  }
	 int  repeatetime=maxNum/threadNum;
	 int  mod=maxNum%threadNum;
	  
	 CountDownLatch  lock=new CountDownLatch(threadNum);
	 List<RASThread> ths=new ArrayList();
	 for(int i=1;i<=threadNum;i++) {
		 int startNum;
		 if(this.asc)
			 startNum=i;
		 else
			 startNum=maxNum-i+1;
		 RASThread  itm=new  RASThread(startNum,threadNum,repeatetime,lock,asc);
		 ths.add(itm);
	 }
	 
	 for(int i=0;i<threadNum-1;i++) {
		 ths.get(i).setNextTowake(ths.get(i+1));
	 }
	 ths.get(threadNum-1).setNextTowake(ths.get(0));
	 
	 if(mod>0)
		 ths.get(threadNum-1).setOther(mod);
	 
	 for(RASThread itm:ths)
		 itm.start();
	 
	 try {
		lock.await();
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	 System.out.println(" 開始輸出 ");
	 ths.get(0).resume();
  }
  
  
  
   class RASThread extends Thread{
		private CountDownLatch  lock;
		private  Thread nextTowake;
		private int star;
		private int interval;
		private int other=0;//額外需要輸出的數字 可能不被整除 
		
		private int repeatTime;
		private int asc;
		
		RASThread(int star,int interval,int repeatTime,CountDownLatch  lock,Boolean ASC){
			this.star=star;
			this.interval=interval;
			this.lock=lock;
			this.repeatTime=repeatTime;
			if(ASC)
				this.asc=1;
			else
				this.asc=-1;
		}
		
		public void run() {
		   lock.countDown();
		   System.out.println(Thread.currentThread().getName()+"  start");
		   super.suspend();
		   for(int i=0;i<repeatTime;i++) {
			  System.out.println(Thread.currentThread().getName()+" :"+(star+i*interval*asc)); 
			  nextTowake.resume();
			  if(i+1>=repeatTime) {
				  if(other>0) {
					  otherToWrite(star+i*interval*asc);
				  }
				  return ;
			  }
			  super.suspend();
		   }
		}
		public void setNextTowake( Thread nextTowake) {
			this.nextTowake = nextTowake;
		}
		
		private void otherToWrite(int from) {
			for(int i=1;i<=other;i++) {
				System.out.println(Thread.currentThread().getName()+" :"+(from+i*asc)); 
			}
		}
		
	   public void setOther(int other) {
		   if(other>0)
			   this.other=other;
	   }
	}
}

從1開始 指定最大值 在指定線程個數  按照順序或者倒序不同線程交替 不使用同步 輸出

 

public static void main(String[] args) {
	 OrderNumWithNumThreadWithDESC tt=new OrderNumWithNumThreadWithDESC(1000,30,false);
	 tt.init();


.....
Thread-6 :904
Thread-7 :903
Thread-8 :902
Thread-9 :901
Thread-10 :900
Thread-11 :899
Thread-12 :898
Thread-13 :897
Thread-14 :896
Thread-15 :895
Thread-16 :894
Thread-17 :893
Thread-18 :892
Thread-19 :891
Thread-20 :890
.....
Thread-17 :473
Thread-18 :472
Thread-19 :471
Thread-20 :470
Thread-21 :469
Thread-22 :468
Thread-23 :467
Thread-24 :466
Thread-25 :465
Thread-26 :464
Thread-27 :463
Thread-28 :462
.....
Thread-25 :15
Thread-26 :14
Thread-27 :13
Thread-28 :12
Thread-29 :11
Thread-29 :10
Thread-29 :9
Thread-29 :8
Thread-29 :7
Thread-29 :6
Thread-29 :5
Thread-29 :4
Thread-29 :3
Thread-29 :2
Thread-29 :1