认真阅读完这篇文章熟练掌握热门面试题——多线程（源码案例详解）

曾经终败给现在 2023-10-01 17:26 11阅读 0赞

### 问题一：写一个程序，证明AtomicInteger类比synchronized更高效 ###

synchronized更高效  
案例一

package duoxiancheng2;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * @author yeqv
     * @program A2
     * @Classname Ms4
     * @Date 2022/2/7 20:04
     * @Email w16638771062@163.com
     */
    public class Ms4 {
        
    
        AtomicInteger n = new AtomicInteger(10000);
        int num = 10000;
    
        public static void main(String[] args) {
        
    
            var t = new Ms4();
            new Thread(t::minus, "T1").start();
            new Thread(t::minus, "T2").start();
            new Thread(t::minus, "T3").start();
            new Thread(t::minus, "T4").start();
            new Thread(t::minus, "T5").start();
            new Thread(t::minus, "T6").start();
            new Thread(t::minus, "T7").start();
            new Thread(t::minus, "T8").start();
    
        }
    
        void minus() {
        
            var a = System.currentTimeMillis();
            while (true) {
        
               /* if (n.get() > 0) {
                    n.decrementAndGet();
                    System.out.printf("%s 售出一张票，剩余%d张票。 %n", Thread.currentThread().getName(), n.get());
                } else {
                    break;
                }*/
                synchronized (this) {
        
                    if (num > 0) {
        
                        num--;
                        System.out.printf("%s 售出一张票，剩余%d张票。 %n", Thread.currentThread().getName(), num);
                    } else {
        
                        break;
                    }
    
    
                }
    
    
            }
            var b = System.currentTimeMillis();
            System.out.println(b - a);
        }
    }

**synchronized结果：**  
![在这里插入图片描述][8c80a9de83334ab1b1449bd8612788f1.png]  
**AtomicInteger结果：**  
![在这里插入图片描述][18182e2c7e82435384e19794efecee58.png]

### 问题二：写一个程序证明AtomXXX类的多个方法并不构成原子性 ###

package demo16;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * 写一个程序证明AtomXXX类的多个方法并不构成原子性
     */
    public class T {
        
        AtomicInteger count = new AtomicInteger(0);
    
        void m() {
        
            for (int i = 0; i < 10000; i++) {
        
                if (count.get() < 100 && count.get() >= 0) {
         //如果未加锁,之间还会有其他线程插进来
                    count.incrementAndGet();
                }
            }
        }
    
        public static void main(String[] args) {
        
            T t = new T();
            List<Thread> threads = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
        
                threads.add(new Thread(t::m, "thread" + i));
            }
            threads.forEach(Thread::start);
            threads.forEach((o) -> {
        
                try {
        
                    //join()方法阻塞调用此方法的线程,直到线程t完成，此线程再继续。通常用于在main()主线程内，等待其它线程完成再结束main()主线程。
                    o.join(); //相当于在main线程中同步o线程，o执行完了，main线程才有执行的机会
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            System.out.println(t.count);
        }
    }

\*\*

### 问题三：写一个程序，在main线程中启动100个线程，100个线程完成后，主线程打印“完成” ###

package cn.thread;
    
    import java.util.concurrent.CountDownLatch;
    
    /**
     * 写一个程序，在main线程中启动100个线程，100个线程完成后，主线程打印“完成”
     *
     * @author webrx [webrx@126.com]
     * @version 1.0
     * @since 16
     */
    public class T12 {
        
        public static void main(String[] args) {
        
            CountDownLatch latch = new CountDownLatch(100);
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> {
        
                    String tn = Thread.currentThread().getName();
                    System.out.printf("%s : 开始执行...%n", tn);
                    System.out.printf("%s : 执行完成，程序结束。%n", tn);
                    latch.countDown();
                }, "T" + i).start();
            }
    
            try {
        
                latch.await();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("---------------------------------------");
            System.out.println("100个线程执行完了。");
            String tn = Thread.currentThread().getName();
            System.out.printf("%s : 执行完成，程序结束。%n", tn);
        }
    }

[8c80a9de83334ab1b1449bd8612788f1.png]: https://img-blog.csdnimg.cn/8c80a9de83334ab1b1449bd8612788f1.png
[18182e2c7e82435384e19794efecee58.png]: https://img-blog.csdnimg.cn/18182e2c7e82435384e19794efecee58.png