线程面试手撕代码总结

你的名字 2023-10-14 11:17 19阅读 0赞

### 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();
            }