java八股文面试[多线程]——两个线程交替打印1-100之间的数字

一份代码，两个线程，使用synchronize实现：

• 重写run()方法，将输出1到100之间整数的代码写到同步方法里。
• 线程1进入到同步方法，输出一个整数后，阻塞并释放锁。
• 线程2进入到同步方法，唤醒线程1，输出整数后，阻塞并释放锁。
• 线程1和线程2重复第3步，直到输出所有的整数。

public class PrintNumThread extends Thread {
 
    static int num = 0;
    static Object object = new Object();
 
    @Override
    public void run() {
 
        while (true) {
 
            synchronized (object) {
                //唤醒等待的线程 必须在同步代码块中
                object.notify();
                if (num < 100) {
                    num++;
                    System.out.println(Thread.currentThread().getName()+":"+num);
                } else {
                    break;
                }
                try {
                    /*
                    wait()  必须在同步代码块中使用，
                            必须是使用同步锁调用wait()
                            wait()调用后，锁会释放
                            必须要通过其他线程来唤醒
                     */
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    public static void main(String[] args) {
 
        PrintNumThread p1 = new PrintNumThread();
        PrintNumThread p2 = new PrintNumThread();
                       p1.start();
                       p2.start();
    }
}

两个不同的线程：

不使用锁，利用volatile实现

定义一个static的flag，交替修改0 1 ，

//两个线程，一个打印奇数，一个打印偶数
public class OneToHundred{
   static volatile int flag = 0;
   public static void main(String[] args){
      new Thread(new Task1(),"A").start();
      new Thread(new Task2(),"B").start();
   }
}

class Task1 implements Runnable{
   @Override
   public void run(){
     int i = -2;
     while(i<=99){
       if(OneToHundred.flag == 0){
          i+=2;
          System.out.println("a:" + i);
          OneToHundred.flag = 1;
       }
     }
   }
}

class Task2 implements Runnable{
   @Override
   public void run(){
     int i = -1;
     while(i<=98){
       if(OneToHundred.flag == 1){
          i+=2;
          System.out.println("b:" + i);
          OneToHundred.flag = 0;
       }
     }
   }
}

使用ReentranLock(固定一个打印奇数，一个打印偶数)

//三实现的方式，虽然也是一个打印奇数，一个打印偶数，但是A打印奇数还是偶数是随机的，即A打印奇数，则B打印偶
//如果A随机打印的是偶数，那么B打印奇数
//现在固定，A就是打印奇数，B就是打印偶数
public class OneToHundred {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread( new Task(1),"A");
        Thread t2 = new Thread( new Task(0),"B");
        t1.start();
        t2.start();
    }
}

class Task implements Runnable{
   private static int number = 0;
   private int flag = 0;
   private static ReentrantLock lock = new ReentrantLock();
   private static Condition condition = lock.newCondition();
   
   Task(int flag){
     this.flag = flag;
   }
   @Override
   public void run(){
     while(number < 100){
       lock.lock();
       if(number >=100) break;
       if(b % 2 == this.flag){
          flag++;
       }else{
          try{
            condition.await();
          }catch (InterruptedException e) {
            e.printStackTrace();
          } 
       }
       condition.signalAll();
       lock.unlock();
     }
   }
}

在Condition对象中，与wait() ，notify() ,notifyAll()方法分别对应的是await() , signal() ,signalAll()方法。Condition实例实质上被绑定到一个锁上。要为特定Lock实例获得Condition实例，使用其newCondition()方法。
将第一个Number类改成以下代码，也可以实现一样的结果。
 

知识来源：

两个线程交替打印1-100之间的数字_线程交替打印1到100_叫我剑锋的博客-CSDN博客

两个线程交替打印1-100_两个线程交替打印1到100_一 路的博客-CSDN博客

两个线程交替打印1-100_两个线程交替打印1到100_一 路的博客-CSDN博客