1-12练习

1. 双线程猜数字

用两个线程玩猜数字游戏，第一个线程负责随机给出1~10之间的一个整数，第二个线程负责猜出这个数。

要求：每当第二个线程给出自己的猜测后，第一个线程都会提示“猜小了”、“猜 大了”或“猜对了”。

猜数之前，要求第二个线程要等待第一个线程设置好 要猜测的数。

第一个线程设置好猜测数之后，两个线程还要相互等待，

其原 则是：第二个线程给出自己的猜测后，等待第一个线程给出的提示；

第一个 线程给出提示后，等待第二个线程给出猜测，如此进行，直到第二个线程给 出正确的猜测后，两个线程进入死亡状态。

public class Task1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread15 t2=new MyThread15();
        MyThread14  t1=new MyThread14(t2);
        t2.setDaemon(true);
        t1.start();
        t2.start();
        t1.join(100);
    }
}
public class MyThread14 extends Thread {
    static String lock = "guess1";
    int x;
    Random r = new Random();
    MyThread15 myThread15;

    public MyThread14(MyThread15 m) {
        myThread15 = m;
    }
    @Override
    public void run() {
        synchronized (lock) {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        x = r.nextInt(1, 11);
        while (myThread15.loop) {
            synchronized (lock) {
                if (x > myThread15.answer)
                    System.out.println("你猜小了");
                else if (x < myThread15.answer)
                    System.out.println("你猜大了");
                else {
                    myThread15.loop = false;
                    System.out.println("你猜对了");
                }
                lock.notifyAll();
                try {
                    if (myThread15.loop)
                        lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
public class MyThread15 extends Thread {
    int answer;
    Scanner scan = new Scanner(System.in);
    boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            synchronized (MyThread14.lock) {
                System.out.println("请猜数");
                answer = scan.nextInt();
                MyThread14.lock.notifyAll();
                try {
                    MyThread14.lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

2. 写两个线程，一个线程打印1~52，另一个线程打印字母A~Z。打印顺序为12A34B56C........5152Z。要求用线程间的通信

public class Task2 {
    public static void main(String[] args) throws InterruptedException {
        MyThread16 myThread16=new MyThread16();
        MyThread17 myThread17=new MyThread17();
        myThread16.start();
        myThread17.start();
        myThread16.join(100);
    }
}

public class MyThread16 extends Thread {
    int i = 0;
    public static String lock = "lock";
    @Override
    public void run() {
        while (i <= 50) {
            synchronized (lock) {
                System.out.print(++i+" ");
                System.out.print(++i+" ");
                try {
                    lock.notifyAll();
                    if(i<52)lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public class MyThread17 extends Thread{
    char c='A';
    public void run()   {
        while(c<='Z'){
            synchronized (MyThread16.lock){
                System.out.print(c+" ");
                c++;
                MyThread16.lock.notifyAll();
                try {
                    if(c<='Z') MyThread16.lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}