线程面试手撕代码总结

1.交替打印ABC n次（Synchronized+wait/notify）

//synchronized+wait/notify
    private int num;
    private static  final Object LOCK=new Object();
    int n=10;
    private  void printABC(String name,int targetNum){
        for(int i=0;i<n;i++){
        synchronized (LOCK){
            while(num%3!=targetNum){
                try{
                    LOCK.wait();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            num++;
            System.out.println(name);
            LOCK.notifyAll();
        }}
    }

    public static void main(String[] args) {
        occur occur=new occur();
        new Thread(()->{
          occur.printABC("A",0);
        }).start();
        new Thread(()->{
            occur.printABC("B",1);
        }).start();
        new Thread(()->{
            occur.printABC("C",2);
        }).start();
    }

2.交替打印ABC n次，利用join()

 static class printABC implements Runnable{
        private Thread beforeThread;
        public printABC(Thread beforeThread){
            this.beforeThread=beforeThread;
        }
        @Override
        public void run() {
            if(beforeThread!=null){
                try {
                    beforeThread.join();
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }else{
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        int i=0;
        while(i<10){
            Thread t1=new Thread(new printABC(null),"A");
            Thread t2=new Thread(new printABC(t1),"B");
            Thread t3=new Thread(new printABC(t2),"C");
            t1.start();
            t2.start();
            t3.start();
            i++;
        }
    }

3.交替打印ABC n次，利用 Lock+Condition

private int num;
    private static Lock lock=new ReentrantLock();
    private static Condition c1= lock.newCondition();
    private static Condition c2= lock.newCondition();
    private static Condition c3= lock.newCondition();

    private void printABC(String name,int targetNum,Condition currentThread,Condition nextThread){
        for(int i=0;i<10;i++){
            lock.lock();
            try{
                while(num%3!=targetNum){
                    currentThread.await();
                }
                num++;
                System.out.println(name);
                nextThread.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        occur occur=new occur();
        new Thread(()->{
            occur.printABC("A",0,c1,c2);
        }).start();
        new Thread(()->{
            occur.printABC("B",1,c2,c3);
        }).start();
        new Thread(()->{
            occur.printABC("C",2,c3,c1);
        }).start();
    }

4.交替打印ABC n次，利用Semaphore

 private static Semaphore c1=new Semaphore(1);
    private static Semaphore c2=new Semaphore(0);
    private static Semaphore c3=new Semaphore(0);

    private void printABC(String name,int targetNum,Semaphore currentThread,Semaphore nextThread){
        for(int i=0;i<10;i++){
            try{
                currentThread.acquire();
                System.out.println(name);
                nextThread.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        occur occur=new occur();
        new Thread(()->{
            occur.printABC("A",0,c1,c2);
        }).start();
        new Thread(()->{
            occur.printABC("B",1,c2,c3);
        }).start();
        new Thread(()->{
            occur.printABC("C",2,c3,c1);
        }).start();
    }

5.交替打印奇偶数

 private static  final Object monitor=new Object();
    private volatile int count;
    public occur(int initCount){
        this.count=initCount;}
    private void printOddEven(){
       synchronized (monitor){
           while(count<50){
               System.out.println(Thread.currentThread().getName()+":");
               System.out.println(++count);
               monitor.notifyAll();
               try {
                   monitor.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           monitor.notifyAll();
        }
    }


    public static void main(String[] args) throws InterruptedException {
     occur occur=new occur(0);
     new Thread(occur::printOddEven,"odd").start();
     Thread.sleep(10);
     new Thread(occur::printOddEven,"even").start();
    }

6.3个线程交替打印10以内的数

  private int num;
    private static final Object monitor=new Object();
    private int Maxnum=10;
    private void printOddEven(String name,int tarNum){
           while(true){
               synchronized (monitor){
                    if(num>=Maxnum){
                       break;
                   }
                   num++;
                   System.out.println(Thread.currentThread().getName()+":"+num);
                   monitor.notifyAll();
               while(num%3!=tarNum){
                   if(num>=Maxnum){
                       break;
                   }
                   try{
                       monitor.wait();
                   }catch (InterruptedException e){
                       e.printStackTrace();
                   }
               }
               
        }}
    }


    public static void main(String[] args) throws InterruptedException {
     occur occur=new occur();
     new Thread(()->{
         occur.printOddEven("thread1",0);
     },"thread1").start();
        new Thread(()->{
            occur.printOddEven("thread2",1);
        },"thread2").start();
        new Thread(()->{
            occur.printOddEven("thread3",2);
        },"thread3").start();
    }

7.轮流打印数字、字符

   static class PrintThread implements Runnable {
        private static final Object lock = new Object();
        private static int num = 1;
        private static char ch = 'A';
        private final boolean isNumberThread;

        public PrintThread(boolean isNumberThread) {
            this.isNumberThread = isNumberThread;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    if (isNumberThread) {
                        // 如果是数字线程，则打印数字并增加num变量
                        if (num <= 26) {
                            System.out.print(num + " ");
                            num++;
                        } else {
                            break;
                        }
                    } else {
                        // 如果是字符线程，则打印字符并增加ch变量
                        if (ch <= 'Z') {
                            System.out.print(ch + " ");
                            ch++;
                        } else {
                            break;
                        }
                    }
                    // 通知另一个线程运行
                    lock.notify();

                    try {
                        // 当前线程暂停，等待另一个线程打印
                        if (num <= 26 || ch <= 'Z') {
                            lock.wait();

                        } else {
                            break;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

        public static void main(String[] args) {
            Thread t1 = new Thread(new PrintThread(true)); // 数字线程
            Thread t2 = new Thread(new PrintThread(false)); // 字符线程
            t1.start();
            t2.start();
        }