写两个线程，其中一个线程打印1-52，另一个打印A-Z，打印顺序为12A34B56C....5152Z_自定义两个线程类printnum和printword,一个线程(printnum类对象)负责打印1~-CSDN博客

本文链接：https://blog.csdn.net/anlian523/article/details/73577177

这是疯狂java讲义的一道题。在网上能搜到各种正确答案，有各种不同版本。在此我整理了一下，然后把其中的道理归纳总结一下。下面列出了各个版本：

1.有四个类，一个打印类，两个线程类，和一个测试类。打印类里面用的同步方法，线程类是继承thread，不仅控制循环次数，还控制打印的字符串。执行完毕并没有阻塞，因为设置了阻塞的终点。

package testone;


public class print {

	private boolean flag=true;//为真打印数字，为假打印字母
	
	public print() {
		
	}

	public synchronized void printNumber(String s)
	{
		try
		{
			if(!flag)
			{
				wait();
			}
			//为真时进入
				System.out.print(s);
				flag=false;
				notifyAll();
			
		}
		catch(InterruptedException ex)
		{
			ex.printStackTrace();
		}
	}
	
	public synchronized void printLetter(String s)
	{
		try
		{
			if(flag)
			{
				wait();
			}
			//为假时进入
				System.out.print(s);
				flag=true;
				notifyAll();
			
		}
		catch(InterruptedException ex)
		{
			ex.printStackTrace();
		}
	}

}

package testone;

public class numthread extends Thread{

	public print printer;
	public numthread(String name,print printer) {
		super(name);
		this.printer=printer;
		// TODO Auto-generated constructor stub
	}

	public void run()
	{
		int count=0;
		for(int i=1;i<=26;i++)
		{
			count++;
		  String s=(2*i-1)+" "+2*i+" ";
		  printer.printNumber(s);
		}
		
	}
}

package testone;

public class letterthread extends Thread {

	public print printer;
	public letterthread(String name,print printer) {
		super(name);
		this.printer=printer;
		// TODO Auto-generated constructor stub
	}

	public void run()
	{
		for(int i=1;i<=26;i++)
		{
		  int temp=i+64;
		  char c=(char) temp;
		  printer.printLetter(c+" ");
		}
	}
	
}

package testone;

public class printTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		print printer=new print();
		new numthread("打印数字线程",printer).start();;
		new letterthread("打印字母线程",printer).start();
		
	}

}

这是我最开始想到的版本，但是犯了个严重的错误，错误代码如下

package testone;


public class print {

	private boolean flag=true;//为真打印数字，为假打印字母
	
	public print() {
		
	}

	public synchronized void printNumber(String s)
	{
		try
		{
			if(!flag)
			{
				wait();
			}
			else//为真时进入
			{
				System.out.print(s);
				flag=false;
				notifyAll();
			}
		}
		catch(InterruptedException ex)
		{
			ex.printStackTrace();
		}
	}
	
	public synchronized void printLetter(String s)
	{
		try
		{
			if(flag)
			{
				wait();
			}
			else//为假时进入
			{
				System.out.print(s);
				flag=true;
				notifyAll();
			}
		}
		catch(InterruptedException ex)
		{
			ex.printStackTrace();
		}
	}

}

错误在于，打印方法里面，一旦进入if，那么进行wait阻塞，就算之后另一个线程唤醒了它，也没有打印操作了。如果要保留else的这种写法，那么循环次数必须是52次，而不是26次，因为进入if26次加上进入else26次，而且交换着进入。

2.有四个类，一个打印类，两个线程类，和一个测试类。打印类里面用的同步方法，方法还控制打印的字符串的起点和终点，线程类是继承thread，只控制循环次数。执行完毕并没有阻塞，因为设置了阻塞的终点。

package testTWO;

class Print {             //同步监视器是Print类
    private int i = 1;
    private char j = 'A';
 
    public Print() {
    }
 
    public synchronized void printNumber() {//同步方法
        System.out.print(String.valueOf(i) + String.valueOf(i + 1));
        i += 2;
        notifyAll();      //先唤醒其他进程，再阻塞本进程，如果顺序颠倒了，进程阻塞后不能再唤醒其他进程
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    public synchronized void printWord() {
        System.out.print(j);
        j++;
        notifyAll();
        try
        {
            if (j <= 'Z')//输出Z之后就不用再等待了。
            {
 
                wait();
            }
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
}

package testTWO;

class PrintNumber extends Thread {//打印数字线程
    private Print p;
 
    public PrintNumber(Print p) {
        this.p = p;
    }
 
    public void run() {
        for (int i = 0; i < 26; i++) {
            p.printNumber();
        }
    }
}

package testTWO;

class PrintWord extends Thread {//打印字母线程
    private Print p;
 
    public PrintWord(Print p) {
        this.p = p;
    }
 
    public void run() {
        for (int i = 0; i < 26; i++) {
            p.printWord();
        }
    }
}

package testTWO;

public class PrintTest {
    public static void main(String[] args)
    {
        Print p = new Print();
        Thread t1 = new PrintNumber(p);
        Thread t2 = new PrintWord(p);
        
        t2.start();t1.start();
        //同步监视器设置好了数据的初值，而且设置好了每次运行方法的方法体
        //而线程只是控制了循环次数和执行同步监视器的方法
        //t1,t2.start这两条语句交换顺序，则t1线程在最后会一直阻塞，因为程序没有为t1设置不阻塞的终点
        //因为只有两个线程，所以没有用到flag
    }
}

感觉这样好像更符合面对对象的思想，线程最好还是只控制循环次数，当然这是指同步监视器有方法可以用的时候，如果只是用无意义的object作为同步监视器，那么线程还得控制每次循环的操作。

3.有三个类，两个线程类，一个测试类。线程类用的同步代码块，不仅控制循环次数，还控制每次循环的输出。同步监视器是object，当然这里也可以新建个打印类，把打印类作为监视器，然后线程执行打印类的方法就行。但是感觉原来这样更方便了，毕竟只要满足题意就够了。执行完毕没有阻塞因为有终点。

package testTHRRE;

class Thread1 extends Thread
{
    private Object obj;
     
    public Thread1(Object obj)
    {
        this.obj = obj;
    }
     
    public void run()
    {
        synchronized (obj)
        {
            // 打印1-52
            for (int i = 1; i < 53; i++)
            {
                System.out.print(i + " ");
                if (i % 2 == 0)
                {
                    // 不能忘了 唤醒其它线程
                    obj.notifyAll();
                    try
                    {
                        obj.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
         
    }}

package testTHRRE;

class Thread2 extends Thread
{
    private Object obj;
     
    public Thread2(Object obj)
    {
        this.obj = obj;
    }
     
    public void run()
    {
        synchronized (obj)             //同步监视器是obj类，同步代码块是写在run方法里面的。
        {
            // 打印A-Z
            for (int i = 0; i < 26; i++)
            {
                System.out.print((char)('A' + i) + " ");
                // 不能忘了 唤醒其它线程
                obj.notifyAll();
                try
                {
                    // 最后一个就不要等了
                    if (i != 25)
                    {
                        obj.wait();
                    }
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                 
            }
             
        }
    }
     
}

package testTHRRE;

public class ThreadDemo
{
    // 测试
    public static void main(String[] args) throws Exception
    {
        Object obj = new Object();
        // 启动两个线程
        Thread1 t1 = new Thread1(obj);
         
        Thread2 t2 = new Thread2(obj);
         
        t1.start();
        t2.start();
        //虽然同步监视器只是个无意义的object，但是有了监视器却保证了有了监视，两个线程可以交替执行，
        //因为是两个，所以不需要用到flag
        //t1,t2.start这两条语句交换顺序，则t1线程在最后会一直阻塞，因为程序没有为t1设置不阻塞的终点
    }
     
}

4.这个版本相当于是第一版本的错误版，保留else，所以循环次数为52。但是有一点不一样的是，线程只控制循环次数，打印类控制输出操作是什么。

package testFour;

class Print
{
    private boolean flag = false;
    public int num = 1;
    public char chr = 'A';
    public synchronized void printNumber()
    {
        try
        {
            if(flag)
            {
                if(num <= 52)
                {
                    wait();
                }
            }
            else
            {
            	//进入else进入了26次
                System.out.print(num);
                System.out.print(num + 1);
                num += 2;
                flag = true;
                notify();
            }
        }
        catch(InterruptedException ie)
        {
            ie.printStackTrace();
        }
    }
     
    public synchronized void printWord()
    {
        try
        {
            if(!flag)
            {
                if(chr <= 'Z')
                {
                    wait();
                }
            }
            else
            {
                System.out.print(chr);
                chr += 1;
                flag = false;
                notify();
            }
        }
        catch(InterruptedException ie)
        {
            ie.printStackTrace();
        }
    }
}

package testFour;

class PrintNumber extends Thread
{
    Print p;
    PrintNumber(Print p)
    {
        this.p = p;
    }
    public void run()
    {
        for(int i = 0; i < 52; i ++)
        {
            p.printNumber();
        }
    }
}

package testFour;

class PrintWord extends Thread
{
    Print p;
    PrintWord(Print p)
    {
        this.p = p;
    }
    public void run()
    {
        for(int i = 0; i < 52; i ++)
        {
            p.printWord();
        }
    }
}

package testFour;

public class test1
{
    public static void main(String[] args) {
        Print p = new Print();
        new PrintNumber(p).start();
        new PrintWord(p).start();
    }
}

4.5 在4版本上升级下，用实现runnable接口来实现线程，新建一个匿名类。

package testFour;

class Print
{
    private boolean flag = false;
    public int num = 1;
    public char chr = 'A';
    public synchronized void printNumber()
    {
        try
        {
            if(flag)
            {
                if(num <= 52)
                {
                    wait();
                }
            }
            else
            {
            	//进入else进入了26次
                System.out.print(num);
                System.out.print(num + 1);
                num += 2;
                flag = true;
                notify();
            }
        }
        catch(InterruptedException ie)
        {
            ie.printStackTrace();
        }
    }
     
    public synchronized void printWord()
    {
        try
        {
            if(!flag)
            {
                if(chr <= 'Z')
                {
                    wait();
                }
            }
            else
            {
                System.out.print(chr);
                chr += 1;
                flag = false;
                notify();
            }
        }
        catch(InterruptedException ie)
        {
            ie.printStackTrace();
        }
    }
}

package testFour;

public class test2 {
    public static void main(String[] args) {
        Print p = new Print();
        new Thread(new Runnable() {
             
            @Override
            public void run() {
                // TODO Auto-generated method stub
                for(int i = 0; i < 52; i ++)
                {
                    p.printNumber();
                }
            }
        }).start();
        new Thread(new Runnable() {
             
            @Override
            public void run() {
                // TODO Auto-generated method stub
                for(int i = 0; i < 52; i ++)
                {
                    p.printWord();
                }
            }
        }).start();
    }
}

5.两个类，打印类和测试类。为了线程实现同步，不用同步方法或者同步代码块了，而是用lock和condition来实现加锁解锁和等待唤醒。线程是用runnable接口实现，而且不是用的普通建立匿名类的方法，而是用的lambda表达式，因为runnable也是个函数式接口。用线程池newCachedThreadPool来调度线程。

package testSix;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Print
{
    private boolean flag = false;
    public int num = 1;
    public char chr = 'A';
    
    private final Lock lock=new ReentrantLock();
    private final Condition cond=lock.newCondition();
    
    public void printNumber()
    {
    	lock.lock();
        try
        {
            if(flag)
            {
                if(num <= 51)
                {
                    cond.await();
                }
            }
            else
            {
            	//进入else进入了26次
                System.out.print(num);
                System.out.print(num + 1);
                num += 2;
                flag = true;
                cond.signalAll();
            }
        }
        catch(InterruptedException ie)
        {
            ie.printStackTrace();
        }
        finally
        {
        	lock.unlock();
        }
    }
     
    public void printWord()
    {
    	lock.lock();
        try
        {
            if(!flag)
            {
                if(chr <= 'Z')
                {
                    cond.await();
                }
            }
            else
            {
                System.out.print(chr);
                chr += 1;
                flag = false;
                cond.signalAll();
            }
        }
        catch(InterruptedException ie)
        {
            ie.printStackTrace();
        }
        finally
        {
        	lock.unlock();
        }
    }
}

package testSix;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;



public class printTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Print p = new Print();
		ExecutorService service = Executors.newCachedThreadPool();  
		service.execute(()->{
            for(int i = 0; i < 52; i ++)
            {
                p.printNumber();
            }
        
             });
		service.execute(()->{
            for(int i = 0; i < 52; i ++)
            {
                p.printWord();
            }
        
             });
		
		
	}

}

总结一下：1.其实两个线程不需要设置flag，但是应该熟悉这种编程思路，不用flag的话，那么就在代码块最后先notifyall，再wait，就好了，顺序不能反。

2.哪个线程先start，就先执行。而此题过程很明确，很方便设置堵塞的终点。

3.为了更符合面对对象，尽量只让线程类控制循环次数，把实际的方法写在同步监视器的实际方法，最后只是让线程调用就行。为了少新建类，可以多用lamdba表达式创建runnable对象。