多线程经典题——顺序打印1-75

今天学习了线程安全，碰到了这个题目：

启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10,
  然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....
  以此类推, 直到打印到75. 程序的输出结果应该为:
 
   线程1: 1
   线程1: 2
   线程1: 3
   线程1: 4
   线程1: 5
 
   线程2: 6
   线程2: 7
   线程2: 8
   线程2: 9
   线程2: 10
   ...
 
   线程3: 71
   线程3: 72
   线程3: 73
   线程3: 74
   线程3: 75
这道题可以用三个自定义线程类做，但是觉得太麻烦了，而且没有用到synchronized修饰，所以如果通过对象锁的思路是：主线程中放一个循环1-3调用自己定义的一个线程类的start方法，在自定义的类中 构造函数接参，一个是共同的对象object（就用这个对象实现锁）还有一个是i循环的值，因为这题需要按顺序循环打印，就需要判断是否是顺序的，而需要判断就需要找规律，线程三次一循环，一次输出5个，那么在自定义中可以定义一个count来计数，一个打印五次后，count++，然后对3取余，如果值与传入的循环i值相等，则运行打印，不然则调用wait方法，等待应该按顺序执行的i值。

public class work3 {
	public static void main(String[] args) {
		Object obj = new Object();
		for(int i=1;i<=3;i++){//传入对象锁 和 i值
			
			new Thread(new MyThread2(obj,i), "线程"+i).start();
		}
	}
}
class MyThread2 implements Runnable{
	private static int i = 0;//打印的值 1-75
	private static int count=0;//计数 三次一轮回
	private Object obj;
	private int n;//接参 i值
	public MyThread2(Object obj,int n) {
		this.obj=obj;
		this.n = n;
	}
	

	@Override
	public void run() {
		synchronized (obj) {
			while(i<75){//i++ 在代码块 所以到74就可以了
				
				obj.notifyAll();//唤醒所有线程
				
				if(count%3!=(n-1)){ //找出下一个线程  不正确的线程等待
					
					try {
						obj.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				i++;
				System.out.println(Thread.currentThread().getName()+": "+i);
				if(i%5 == 0){ //打印了五次后 此线程让出资源，等待
					try {
						count++; //count是static修饰 ，为了共享
						System.out.println();
						obj.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
	
}

由这题也可以想到另一到多线程题，开启3个线程，这3个线程的ID分别为A、B、C，
 * 每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；
 * 如：ABCABC….依次递推。

顺序输出ABC用synchronized的代码。

上面的代码改动下，不用每次打印五次，只要打印一次，在循环十次

package work;

public class work1_2 {
	public static void main(String[] args) {
		Object obj = new Object();
		for(int i =0;i<3;i++){
			new Thread(new myThreads(obj,""+(char)(i+65),i)).start();
		}
	}
}
class myThreads implements Runnable{
	private Object obj;
	private String name;
	private int i;
	
	private static int count = 0;
	
	public myThreads(Object obj,String name, int i) {
		this.obj = obj;
		this.name = name;
		this.i = i;
	}

	@Override
	public void run() {
		synchronized (obj) {
			for(int n=0;n<10;n++){
				obj.notifyAll();
				if((count)%3!=i){
					try {
						obj.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println(name);
				try {
					count++;
					obj.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
}

当然，这个打印ABC的有更简单的方法，就是sleep，写三个自定义的线程类，A类sleep时间最少，C最多，这样非常容易就实习了。